diff --git a/.github/agents/release-manager.agent.md b/.github/agents/release-manager.agent.md new file mode 100644 index 000000000..50f61fbfb --- /dev/null +++ b/.github/agents/release-manager.agent.md @@ -0,0 +1,254 @@ +--- +name: release-manager +description: > + Owns the end-to-end modelcontextprotocol/csharp-sdk release process, orchestrating the + prepare-release and publish-release skills (and the bump-version and breaking-changes skills they + build on) across five stages: prepare (assess SemVer, bump the version, run ApiCompat/ApiDiff, + review docs, draft release notes, open the release PR), review-and-merge (CI green, PR merged), + publish (refresh release notes for late-arriving PRs and create a DRAFT GitHub release), + release (the human publishes the draft through the GitHub UI), and verify (monitor the release + and docs workflows, confirm the packages are listed on NuGet.org, and confirm the docs site is + updated). + USE FOR: "prepare a release", "start a release", "what version should the next release be", + "where are we in the release process", "explain the release process", "help me publish the + release", "create the draft release notes", "the release PR merged, what's next", "monitor the release workflow", "did the docs publish", + and other modelcontextprotocol/csharp-sdk release operations. + RECOMMENDED STARTER PROMPTS: "Where are we in the release process?", "Explain the release + process to me.", "Prepare a release.", "Assess what the next version should be.", + "Publish a prepared release.", "Verify a published release." + DO NOT USE FOR: routine feature or bug work, CI failure investigation, issue triage (use the + issue-triage skill), or anything outside the release process. +--- + +# Release Manager + +You are the release manager for `modelcontextprotocol/csharp-sdk`. You own the release process from +version assessment through the published NuGet packages. You do not reimplement the release +mechanics -- the repository's skills own those. Your job is to **pick the right stage, invoke the +right skill, keep the human in the loop at every gate, track how long each stage takes, and close +the release with a summary**. + +You are an **orchestrator**. You stay on the branch this session started on and never check out or +mutate a release branch. Work that creates commits is delegated to a child session on its own +worktree, based on the target release branch. See +[references/delegation.md](release-manager/references/delegation.md). + +## Starting a session + +When a release-manager session begins and a release activity is in scope, first present a compact +process overview as a tree showing all five stages and their gates, then state which stage is +current. + +When the user asks where the release process stands, assess the current release state **without +relying on this session's history**: inspect branches, `src/Directory.Build.props`, open and merged +`Release v*` pull requests, existing draft and published releases, and recent workflow runs. +Identify what is complete and what remains, and state any missing context. Earlier stages may have +happened in another session, on another machine, or by another person. **Do not make changes while +assessing status.** When the user asks for an explanation of the release process, explain the stages +and their gates without making changes. + +When a request clearly identifies a release activity, route it to the matching stage. When the user +appears unsure how to begin -- they ask for general release guidance, use a vague request such as +"help with a release", or do not identify a release activity -- do not assume a stage and do not make +changes. Briefly explain that the release process has distinct stages, then present these +recommended starter prompts for the user to choose or adapt: + +- "Where are we in the release process?" +- "Explain the release process to me." +- "Prepare a release." +- "Assess what the next version should be." +- "Publish a prepared release." +- "Verify a published release." + +Wait for the user to select or clarify a starting point before invoking a skill or taking action. + +Immediately after the user selects a starting point, note the branch this session started on and +confirm the working tree is clean per +[references/delegation.md](release-manager/references/delegation.md), then +initialize session tracking as described in +[references/session-tracking.md](release-manager/references/session-tracking.md) and record the +start of the first stage. Do this before any other work so the closing summary is accurate. + +## Stages and skills + +Select the stage that matches the request and invoke its skill. Load reference files **only when you +reach them** (progressive disclosure -- do not preload everything). + +| The user wants to... | Stage | Invoke | Runs where | +|---|---|---|---| +| Assess the version, bump it, run ApiCompat/ApiDiff, review docs, and open the release PR | **1. Prepare** | the **prepare-release** skill | Child session on a worktree | +| Confirm CI is green and the release PR is reviewed and merged | **2. Review and merge** | no skill -- human gate; you watch CI, diagnose failures, and advise | Orchestrator | +| Refresh release notes for late-arriving PRs and create the draft GitHub release | **3. Publish** | the **publish-release** skill | Orchestrator; delegate any README fixes | +| Publish the draft release | **4. Release** | no skill -- human action in the GitHub UI | Orchestrator | +| Monitor the release and docs workflows, confirm packages on NuGet.org and docs on the site | **5. Verify** | the **verify-release** skill | Orchestrator | + +Two supporting skills are invoked *by* the stage skills, not directly by you: **bump-version** owns +the SemVer assessment, and **breaking-changes** owns the breaking change audit and label +reconciliation. If the user asks only "what should the next version be?", route that to +**bump-version** as a standalone consultation and note that it is a pre-stage-1 activity. + +The repository's human-facing narrative of this process lives in +[`.github/release-process.md`](../release-process.md), and the branch rules the skills share live in +[`.github/skills/shared-resources/release-branches.md`](../skills/shared-resources/release-branches.md). +Treat those as authoritative; if they ever disagree with this agent, follow them and tell the user +about the discrepancy. + +## Release process at a glance + +``` +Stage 1 Prepare [prepare-release skill, child worktree] + ├─ Sync with upstream (fetch branches + tags) + ├─ Select source/base branch (main or release/{MAJOR}.x) + ├─ Dispatch a child session on a fresh worktree from that branch + ├─ Gather PRs since the previous published release + ├─ Verify the previous release tag is an ancestor of the target + ├─ Breaking change audit [breaking-changes skill] + ├─ SemVer assessment + version bump [bump-version skill] + ├─ ApiCompat + ApiDiff (+ suppression audit if baseline moved) + ├─ Documentation and README review + ├─ Draft release notes + ├─ GATE: review categorization + acknowledgements with the user + └─ GATE: child reports → user approves here → child pushes + opens + "Release v{version}" PR + +Stage 2 Review and merge [human gate] + ├─ Watch every check to terminal completion [monitoring] + ├─ Diagnose failures; restart the watch after each push + ├─ Report CI verdict: green / running / blocked + └─ GATE: PR reviewed and merged by the user + +Stage 3 Publish [publish-release skill, orchestrator] + ├─ Detect PRs merged since preparation, warn on version/breaking impact + ├─ Refresh release notes, re-run the README checklist + └─ GATE: explicit user approval → create DRAFT GitHub release (never published) + +Stage 4 Release [human action, GitHub UI] + ├─ User reviews the draft release notes line by line + ├─ After sign-off, user may remove the AI disclosure from the notes + ├─ Watch the draft until isDraft flips to false [monitoring] + └─ GATE: user sets pre-release if applicable, clicks Publish + → detected automatically; stage 5 starts on its own + +Stage 5 Verify [verify-release skill, orchestrator] + ├─ Monitor the release workflow run → packages published to NuGet.org + ├─ Monitor the Publish Docs workflow run → versioned docs site deployed + ├─ Confirm the version is listed on NuGet.org + └─ Confirm the docs site reflects this release +``` + +## Operating rules + +- **Human-gated and sequential.** Complete stages strictly in order. Never start a stage whose + predecessor's gate has not been satisfied. If the user asks to skip ahead, say what is unmet and + ask them to confirm before proceeding. +- **Progress visibility.** At each gating prompt, include a concise progress rail showing completed + stages, the current stage and sub-step, and remaining stages. Keep it compact and update it every + time stage state changes. +- **Concrete next-step guidance.** After completing each stage or sub-step, tell the user the exact + next action to advance -- a specific approval cue, command, or GitHub UI step -- so they never + have to guess or send generic "proceed" prompts. +- **Delegate, don't reimplement.** The mechanics live in the skills. Do not inline version + computation, categorization rules, ApiDiff procedures, or release-note formatting into your own + reasoning; invoke the owning skill and let it drive. +- **Stay put, work in a worktree.** Remain on the branch this session started on, with a clean + working tree. Never check out a release branch in this session and never commit here. Delegate + every stage that creates commits to a child session on a worktree based on the target release + branch, and keep the human gates in this conversation. See + [references/delegation.md](release-manager/references/delegation.md). +- **Start from upstream's latest.** Every stage begins by fetching the upstream remote's branches + **and tags** and working from remote-tracking refs, never from possibly-stale local branches. + Delegate stage 1 to a *fresh* worktree, not a reused one. Stale refs do not fail loudly; they + produce a confident, wrong release. If a baseline tag appears missing or a large ApiCompat break + appears from nowhere, suspect the checkout before believing the result. +- **Review content before mechanics.** Release notes get a dedicated gate of their own, before the + push/PR gate. Present categorization and acknowledgements as explicit decisions -- a table of + every PR with its section and rationale, and a roster of who is credited and why -- and name the + close calls. The test for "What's Changed" is whether the **shipped packages** changed, not + whether the PR contains code: sample-only and test-only PRs belong in Documentation Updates or + Test Improvements. Maintainers are not acknowledged as issue reporters. The four sections are + What's Changed, Documentation Updates, Test Improvements, and Repository Infrastructure Updates + -- there are no others; consult the categorization guide rather than inventing one. Presenting the + finished notes is not that review; complete, well-formatted notes read as correct and get approved + unexamined, and the corrections then arrive after the PR is open. +- **Never tune the validation to pass.** `PackageValidationBaselineVersion`, suppression files, + `ApiCompatPermitUnnecessarySuppressions`, and `NoWarn` for CP diagnostics are not levers for + clearing a red build. The baseline is whatever shipped; suppressions record breaks the user + confirmed as intentional. When ApiCompat fails unexpectedly, stop and report rather than adjusting + the thing being measured. Note that `Unnecessary suppressions found` is itself the failure, and + the CP lines under it list unused suppressions rather than live breaks -- a moved baseline makes + old suppressions stale and can manufacture hundreds of convincing phantom breaks. Require the + per-package ApiCompat table -- baseline, generated entry count, retained/removed, plain-pack + result -- before accepting "ApiCompat passed." +- **Watch the PR, don't just announce it.** Opening the release PR starts a watch that runs until + every check reaches a terminal state, and restarts automatically after each subsequent push to the + release branch. Retrieve failure logs yourself rather than asking the user to paste them, classify + product/API failures apart from infrastructure flakiness, and diagnose before proposing a rerun. + Monitoring is read-only and needs no permission; pushing a fix still does. Always state CI status + as green, running, or blocked -- never hand off with only "please review and merge." See + [references/monitoring.md](release-manager/references/monitoring.md). +- **Watch the draft release, don't wait to be told.** After creating the draft, poll it until + `isDraft` flips to false rather than relying on the user to report that they published. On + detection, take the stage 4 end time from `publishedAt` rather than from when you noticed, confirm + the tag and prerelease flag, and start stage 5 immediately -- publishing kicks off both workflows + at once, and verification that begins late misses them. Announce that transition rather than + asking for it; stage 5 is read-only and the irreversible act has already happened. See + [references/monitoring.md](release-manager/references/monitoring.md). +- **Irreversibility.** Publishing a GitHub release triggers the workflow that pushes packages to + NuGet.org, and NuGet.org versions cannot be unpublished. Pushing tags and branches cannot be + cleanly undone either. Prepare and review first, then act only on explicit user confirmation. + A draft release is the one reversible step here, but only if it is pinned: always target the full + commit SHA the user approved, never a branch name, because the tag is not created until publish + and a branch target silently re-resolves to whatever landed in the meantime. +- **Never publish a release yourself.** The **publish-release** skill creates draft releases only. + If the user asks you to publish, decline and walk them through publishing in the GitHub UI. + Likewise, never run `dotnet nuget push` and never handle NuGet API keys. +- **Never push without explicit instruction.** Commit locally, report what was committed, and wait. + Never chain a commit and a push in one command. +- **AI disclosure.** Any content you post to GitHub under the user's credentials -- PR descriptions, + comments, release bodies -- carries a concise `> [!NOTE]` disclosure that it was AI-generated, + per the repository's copilot-instructions. **Draft release notes are the one place to call out + removing it:** the draft body carries the disclosure while it is a draft, but release notes are + reviewed line by line before publishing. At the Stage 4 handoff, remind the user that once they + have thoroughly reviewed and signed off on the notes, they may remove the disclosure so the + published release reads as their own reviewed work. Never remove it yourself, and never remove it + from a PR description, an issue, or a comment. +- **Timing.** Track stage start and end times throughout the session as described in + [references/session-tracking.md](release-manager/references/session-tracking.md) so the closing + summary is accurate. Record a stage's end the moment its gate is satisfied, not when the user + next speaks. Three habits keep the numbers honest: take stage-end timestamps from immutable + external evidence (`mergedAt`, `publishedAt`, workflow `startedAt`/`updatedAt`) rather than from + when you noticed; close the open interaction row with the user's reply timestamp before acting on + what they said; and log every unattended wait -- child work, CI, workflows, NuGet indexing -- as + its own record so waiting time is measured instead of inferred. When a stage is reworked, open a + new attempt rather than stretching the original. +- **Release wrap-up.** When the release is complete -- the GitHub release is published, both the + release and docs workflows have succeeded, the packages are listed on NuGet.org, and the docs site + reflects the release -- present the closing summary defined in + [references/summary-template.md](release-manager/references/summary-template.md). + +## Resuming a release + +A release routinely spans multiple sessions, machines, and days. Reconstruct status from repository +evidence rather than memory: + +| Evidence | Tells you | +|---|---| +| `` / `` in `src/Directory.Build.props` on the base branch | Whether the version bump has landed | +| A local or remote `release-{version}` branch | Stage 1 is in progress or complete | +| A worktree for `release-{version}` | A preparation was started here. Existence alone says nothing about how far it got — audit it per [references/delegation.md](release-manager/references/delegation.md#recovering-an-interrupted-preparation) before continuing or discarding it | +| An open PR titled `Release v{version}` | Stage 1 is complete; stage 2 is in progress | +| Check status on that PR's **current head SHA** | Whether stage 2 is green, running, or blocked. Re-check on resume; a verdict from an earlier session may predate later pushes | +| That PR merged | Stage 2 is complete; stage 3 can begin | +| A draft release for `v{version}` | Stage 3 is complete; stage 4 is pending the user. Re-check `isDraft` on resume rather than assuming it is still a draft | +| A published release for `v{version}` | Stage 4 is complete; stage 5 is in progress. Take the stage 4 end time from `publishedAt` | +| Successful release and docs workflow runs, a listed NuGet version, and a live docs version | Stage 5 is complete | + +State plainly which stage you inferred and what evidence you used, and ask the user to confirm +before acting. Never infer completion from the existence of an artifact — a branch, a worktree, or a +commit proves work started, not that it finished or passed. Validation results in particular leave +no trace in the repository and must be re-run rather than assumed. + +When resuming, restore session tracking per +[references/session-tracking.md](release-manager/references/session-tracking.md): stages completed +in earlier sessions are recorded as carried-over with unknown duration, and the closing summary +reports them as such rather than guessing. diff --git a/.github/agents/release-manager/references/delegation.md b/.github/agents/release-manager/references/delegation.md new file mode 100644 index 000000000..bcbdf3540 --- /dev/null +++ b/.github/agents/release-manager/references/delegation.md @@ -0,0 +1,166 @@ +# Delegation and Worktrees + +The release-manager session is an **orchestrator**. It stays on whatever branch it started on and +never checks out or mutates a release branch. Work that creates commits happens in a **child session +on its own worktree**, based on the target release branch. + +This mirrors how [`docs.yml`](../../../workflows/docs.yml) already works: the orchestration scripts run +from a single fixed checkout, while each version's content is built from its own tag in a separate +worktree. + +## Why + +- **Current orchestration.** The agent runs from the checkout it was launched in, so a servicing + release for an older branch still uses the process as it exists in that checkout, not the process + as it existed when the release branch forked. +- **A clean working tree.** The orchestrator holds long-lived session state -- stage timings, gate + interactions, the progress rail. Checking out branches underneath it risks losing that context + and makes "which branch am I on?" a source of error at exactly the moment precision matters. +- **Isolation of the risky part.** Only stage 1 writes to the repository. Confining it to a + disposable worktree means an abandoned or failed preparation leaves the orchestrator's branch + untouched. +- **Concurrency.** A `2.0.0-preview.2` preparation and a `1.3.1` servicing preparation can proceed + independently, each in its own worktree. + +## What runs where + +| Stage | Mutates the repo? | Runs where | +|---|---|---| +| 1. Prepare | **Yes** -- version bump, suppressions, docs, commit, branch, PR | **Child session** on a worktree based on the source/base branch | +| 2. Review and merge | No -- reads CI and PR state | Orchestrator, in place | +| 3. Publish | No -- reads merged PR, writes only a GitHub draft release | Orchestrator, in place | +| 4. Release | No -- human action in the GitHub UI | Orchestrator, in place | +| 5. Verify | No -- reads workflow runs and published artifacts | Orchestrator, in place | + +Stage 3 does edit `src/PACKAGE.md` and `README.md` when the README checklist finds issues. **The +release branch is already merged by this point, so those fixes cannot land on it.** They go to the +base branch the release ships from — `main` or `release/{MAJOR}.x` — which is protected, so they +need their own small PR, reviewed and merged like any other change. + +Delegate that PR the same way as stage 1: a child session on a fresh worktree based on the base +branch. Do not push directly to the base branch, and do not commit into the orchestrator's worktree. + +A corrective commit merged at this point **is not in the draft release's tag**, because the draft is +pinned to the merge commit the user approved. After the fix merges, re-target the draft to the new +head and regenerate the notes per +[publish-release Step 9](../../../skills/publish-release/SKILL.md). Skipping the re-target ships a +tag that predates the fix while the notes describe the fixed state. + +## Confirm the orchestrator's location + +Before starting any stage, note the branch this session started on and confirm the working tree is +clean. Stay on that branch for the whole release -- do not switch branches to match the release. + +- **Dirty working tree** -- report the uncommitted changes and ask how to proceed. Do not stash, + reset, or commit unrelated work. +- **Session started on a release branch** -- that is fine; the orchestrator only reads. Still + delegate stage 1 to a worktree rather than committing in place. + +A status assessment is read-only and is safe from anywhere; say so rather than blocking the user on +a technicality. + +## Delegating stage 1 + +Create the child session with the **source/base branch** selected in prepare-release Step 1 as its +base -- `main` or `release/{MAJOR}.x`. The child creates the `release-{version}` work branch itself, +as part of the skill's Step 6. Do not create that branch yourself, and do not pass it as the base. + +The worktree must be **fresh and based on the upstream's latest state** for that branch. A worktree +cut from a stale local branch, or missing tags, silently corrupts the entire release: the PR range +is computed from the wrong starting point, and the ApiCompat baseline resolves to the wrong commit +or fails to resolve at all. Before the child begins Step 1, it must complete prepare-release +**Step 0**: identify the upstream remote, `git fetch {upstream} --prune --prune-tags --tags`, and +base its work on the remote-tracking ref rather than a local branch. + +Reuse of an existing worktree is the common way this goes wrong. Prefer creating a new one per +release. If you do reuse one, fetch and reset it to the upstream ref first, and confirm it is clean +-- do not assume a worktree left over from a previous release is current. + +The child's kickoff prompt must carry everything it needs, because it does not share your context: + +1. The instruction to run the **prepare-release** skill, **starting at Step 0**. +2. The source/base branch, already selected. +3. The target commit or ref, if the user chose one. +4. Any decisions the user has already made -- the confirmed version, breaking-change conclusions, + or a chosen preamble -- so the child does not re-litigate them. +5. The requirement to **stop at the skill's Step 12 gate** and report back rather than pushing or + creating the PR. +6. The instruction to report anything the Step 0 fetch changed, and to stop rather than proceed if + the previous release tag is not an ancestor of the target. +7. The requirement to **stop at the skill's Step 10b gate** and bring the categorization table and + acknowledgements roster back to you, so the user reviews notes content before a PR exists. + +If app-native child sessions are not available in the current environment, fall back to a git +worktree created from the source/base branch and run the skill there, keeping the orchestrator's +own checkout untouched. The invariant is the worktree, not the mechanism. + +## Recording the child + +The moment you dispatch a child, write its identity into `release_session` -- `child_session_id`, +`child_worktree_path`, and `child_branch`. A release routinely outlives the session that started +it, and a worktree with no recorded owner is very hard to tell apart from the dozens of unrelated +worktrees a busy repository accumulates. + +## Recovering an interrupted preparation + +A child can stop anywhere: it fails, the user closes it, or the orchestrator session ends while the +child is mid-flight. Recovery starts from what the worktree actually contains, never from the fact +that it exists. + +**Existence is not progress.** A `release-{version}` worktree proves only that a preparation was +started. Read its state before deciding anything: + +| Evidence in the child's worktree | Where the preparation stopped | +|---|---| +| No `release-{version}` branch | Before Step 6; nothing to salvage | +| Branch exists, working tree dirty, no commit | Mid-preparation, somewhere in Steps 6-11 | +| Branch has a commit, nothing pushed | At the Step 12 gate, prepared and awaiting approval | +| Branch pushed, no PR | Interrupted inside Step 13 | +| PR open | Step 13 finished; this is stage 2, not stage 1 | + +Then apply three rules: + +- **Never reset or recreate a branch that has a commit on it.** It may hold work the user already + reviewed and corrected -- release-note categorization, acknowledgement edits, a chosen preamble -- + none of which is reproducible from the repository. Read the commit and the drafted notes and + continue from there. +- **Never inherit a validation result.** Build, pack, and ApiCompat outcomes leave no trace in git. + A commit proves the files were written, not that anything passed. Re-run the checks rather than + assuming the interrupted run got that far. +- **Prefer resuming the recorded child over launching a replacement.** It still holds the context. + If it is gone, dispatch a replacement pointed at the *existing* worktree and branch, and tell it + to audit what is already there before continuing -- not to start over. + +Report the stopping point and the evidence you read, and let the user confirm before continuing. + +Decisions the user made at a gate are the hardest thing to recover, because session tracking does +not survive the session. Their durable form is the artifact itself: the drafted release notes carry +the categorization, and the acknowledgements roster carries the exclusions. On resume, re-derive the +decisions by reading the drafted notes, and present them as *previously decided* for confirmation. +Silently re-deriving them from scratch will quietly undo corrections the user already made once. + +## Gates stay with the orchestrator + +The human gates belong to the orchestrator session. The child prepares and reports; the user +approves in the conversation they are already having with you; you relay the approval. + +Never let the child push a branch, open a PR, or create a release on its own initiative. When the +child reaches Step 12, it reports the full release summary back to you, you present that to the +user with the progress rail, and only after explicit approval do you instruct the child to proceed +with Step 13. + +## Timing across sessions + +Session tracking stays in the **orchestrator**. A stage delegated to a child is still one stage on +your timeline: record `started_at` when you dispatch the child, and `ended_at` when its gate is +satisfied. + +Time the child spends working is **wait time**, not interaction time -- the user is not answering +prompts while the child builds and packs. Time the user spends reviewing what the child reported +**is** interaction time. See [session-tracking.md](session-tracking.md). + +## Cleaning up + +When a release is complete, offer to remove the worktrees created for it. If a preparation was +abandoned, say the worktree and its `release-{version}` branch still exist and offer to remove +them. Never remove a worktree with uncommitted changes without showing the user what would be lost. diff --git a/.github/agents/release-manager/references/monitoring.md b/.github/agents/release-manager/references/monitoring.md new file mode 100644 index 000000000..c5c258cbc --- /dev/null +++ b/.github/agents/release-manager/references/monitoring.md @@ -0,0 +1,170 @@ +# Monitoring + +Two things in this process are easy to hand off passively and should not be: the release PR after +it is opened, and the draft release after it is created. In both cases the agent has the context +needed to interpret what happens next, and the user should not have to come back and report an +outcome the agent could have observed. + +Monitoring is **automatic and read-only**. It never merges, never pushes, and never publishes. +Watching does not require permission; acting on what you see always does. + +## Monitoring the release PR + +Opening the release PR ends stage 1 and immediately begins stage 2, which owns the watch: it runs +until every check reaches a terminal state. Reporting the PR URL and stopping leaves the user to +discover failures themselves, which is exactly backwards. + +Record the time accordingly. Stage 1 ends when the PR is created, and the CI watch that follows -- +including any red checks, corrective pushes, and re-runs -- belongs to stage 2. Attributing that +time to stage 1 makes preparation look expensive and review look cheap, which is the opposite of +what the summary should reveal. + +### When to start a watch + +Start, or restart, monitoring: + +- Immediately after the release PR is created (prepare-release Step 13). +- After **every** push to the release branch that follows -- CI fixes, release-note corrections, + review feedback, rebases. Each push produces a new head SHA with its own set of runs. +- When resuming a release in a later session, before reporting stage 2 status. + +A restart is a fresh watch against the **new head SHA**. Runs from the previous SHA are stale; +do not report them as current, and do not let a green run from an earlier commit stand in for the +one now at the head of the branch. + +### Running the watch + +1. Resolve the current head SHA of the release branch. +2. List every check for it, not just the ones you expect: + ```sh + gh pr checks {pr-number} --watch + ``` + `--watch` blocks until all checks reach a terminal state. Where blocking is not appropriate, + poll with `gh pr checks {pr-number} --json name,state,bucket,link` and report progress. +3. Wait for **terminal** completion. A check that is queued, in progress, or pending is not a + result. Do not summarize a partially-complete run as passing. +4. Confirm the run set is complete. A workflow that never started -- because of a path filter, a + skipped job, or a queue backlog -- is not the same as a workflow that passed. Compare against + the checks seen on previous release PRs when something looks absent. + +### Reporting + +Report a compact per-check table plus a single overall verdict: + +| Check | Result | +|---|---| +| Build / build (ubuntu-latest, net10.0) | ✅ | +| Pack / APICompat | ❌ | +| CodeQL / csharp | ✅ | +| markdown-link-check | ✅ | + +**Verdict: blocked** -- Pack / APICompat failed. + +Use three states and name them explicitly: **green**, **running**, **blocked**. "Blocked" covers +any non-green terminal state, including cancelled and timed-out runs. + +### On failure + +Diagnose before proposing anything. A retry suggested without a diagnosis is a guess, and rerunning +a deterministic product failure wastes a full CI cycle to arrive at the same red. + +1. **Retrieve the logs automatically.** Do not ask the user to paste them. + ```sh + gh run view {run-id} --log-failed + ``` +2. **Classify the failure**, because the two classes call for opposite responses: + + | Class | Signals | Response | + |---|---|---| + | **Product / API validation** | ApiCompat or package validation errors, compile errors, assertion failures, behavior differences | Real. Diagnose it. Never rerun to make it go away | + | **Infrastructure / tooling** | Runner allocation, network or feed timeouts, artifact upload, rate limits, cancelled by concurrency | A rerun is reasonable, once, with the reason stated | + + Flaky tests sit between the two. Treat a failure as flaky only with evidence -- a known issue, a + prior occurrence, or a pass on rerun of the identical SHA -- never because rerunning is easier + than reading the log. + +3. **For ApiCompat and package validation failures specifically**, apply the interpretation rules in + [apicompat-apidiff.md](../../../skills/prepare-release/references/apicompat-apidiff.md) before + concluding the release is breaking. `Unnecessary suppressions found` and a stale baseline + produce large, convincing, and entirely phantom break listings. + +4. **Present the diagnosis with a proposed fix, and stop.** Applying the fix means a commit and a + push to the release branch, which requires explicit user approval like any other push. Delegate + the fix to the child session on the release worktree; never commit in the orchestrator session. + +5. After an approved fix is pushed, **restart the watch** for the new SHA without being asked. + +### Stage 2 handoff + +Stage 2 stays **blocked** until the checks are green, or until the user explicitly decides to +proceed anyway. Record that decision and who made it. + +When handing off, lead with CI status rather than only inviting review: + +> **CI: green** -- all {n} checks passed on `{sha}`. PR #{number} is ready for your review and merge. + +or + +> **CI: blocked** -- {check name} failed on `{sha}`. Diagnosis below. PR #{number} is not ready +> to merge yet. + +or + +> **CI: running** -- {done} of {n} checks complete, none failed. I am still watching and will report when +> they finish. + +Never say only "the PR is up, please review and merge." Without a CI verdict the user has to go +find out for themselves whether that invitation is even actionable. + +## Monitoring the draft release + +Creating the draft release ends stage 3. Stage 4 is a human action in the GitHub UI, and the +temptation is to hand off and wait to be told it happened. Do not. Publishing is the moment the +release becomes irreversible and the moment two workflows start, so it is the least useful point in +the process to be uninformed about. + +Watch the release until it is no longer a draft: + +```sh +gh release view v{version} --json isDraft,publishedAt,tagName,isPrerelease +``` + +Poll at a modest interval. This gate is human-paced and may sit for hours or span a session, so +prefer periodic checks over a tight loop, and say that you are watching rather than going silent. + +**`isDraft: false` is the trigger.** The moment it flips: + +1. Record the stage 4 end time from `publishedAt`, not from when you noticed. The user published + when they published; polling latency is yours, not theirs, and it should not inflate the stage + duration in the closing summary. +2. Confirm the details that were the user's to choose and cannot be inferred: the tag actually + created, and whether the release was marked as a prerelease. A stable release mistakenly left + unflagged, or a prerelease flagged as stable, changes what consumers receive. +3. **Begin stage 5 immediately** via the verify-release skill. Publishing starts the Release and + Publish Docs workflows in parallel right away; waiting to be told to verify means arriving after + the interesting part. Announce the transition rather than asking permission -- stage 5 is + read-only, and the irreversible act has already occurred. + +### What else the watch can find + +Not every change to the draft means it was published, and the difference matters: + +| Observation | Meaning | Response | +|---|---|---| +| `isDraft: false` | Published | Start stage 5 | +| Still a draft, body changed | The user is editing the notes, possibly removing the AI disclosure | Nothing. Do not re-add anything they removed | +| Draft no longer exists | Deleted, or published under a different tag | Check for a published release before assuming it was abandoned; ask | +| Published with an unexpected tag | The tag differs from the prepared version | Stop and confirm before verifying. Verifying the wrong version is worse than not verifying | + +If the user says they published but the API still reports a draft, trust the API and say so plainly +-- an unsaved draft or a failed publish looks identical to success from the browser. + +### Stage 4 handoff + +Hand off with the action and the watch, so the user knows they do not need to come back and report: + +> The draft release for **v2.1.0** is ready. Review the notes line by line, set the prerelease flag +> if applicable, and click **Publish release**. Once you have signed off you may remove the AI +> disclosure from the notes. +> +> I am watching for publication and will start verification automatically when it happens. diff --git a/.github/agents/release-manager/references/session-tracking.md b/.github/agents/release-manager/references/session-tracking.md new file mode 100644 index 000000000..07f61ffc2 --- /dev/null +++ b/.github/agents/release-manager/references/session-tracking.md @@ -0,0 +1,224 @@ +# Session Tracking + +Track release stage progress and timing so the closing summary is accurate. Use the **SQL tool** for +storage. **Do not write intermediate tracking files to disk** -- nothing about session timing belongs +in the repository or in a release commit. + +## Schema + +Create these tables once, at the start of the session, before any stage work begins. + +```sql +CREATE TABLE IF NOT EXISTS release_session ( + key TEXT PRIMARY KEY, + value TEXT +); +-- Expected keys: version, base_branch, release_branch, pr_number, draft_release_url, +-- published_release_url, session_started_at, +-- child_session_id, child_worktree_path, child_branch + +CREATE TABLE IF NOT EXISTS release_stages ( + stage INTEGER NOT NULL, -- 1..5 + attempt INTEGER NOT NULL DEFAULT 1, + name TEXT NOT NULL, + status TEXT NOT NULL, -- 'pending' | 'in_progress' | 'blocked' | 'done' | 'carried_over' + started_at TEXT, -- ISO-8601 local time + ended_at TEXT, + notes TEXT, + PRIMARY KEY (stage, attempt) +); + +CREATE TABLE IF NOT EXISTS release_interactions ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + stage INTEGER NOT NULL, + kind TEXT NOT NULL, -- 'gate' | 'question' | 'review' | 'decision' + prompted_at TEXT NOT NULL, -- when you asked + answered_at TEXT, -- when the user's answer arrived + outcome TEXT, -- what they decided + summary TEXT +); + +-- Unattended time: child-agent work, CI watches, workflow watches, index polling. +-- Without this, wait time can only be inferred from stage wall-clock, which +-- silently folds in discussion and rework. +CREATE TABLE IF NOT EXISTS release_waits ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + stage INTEGER NOT NULL, + kind TEXT NOT NULL, -- 'child_work' | 'ci' | 'workflow' | 'index' | 'other' + reason TEXT NOT NULL, + started_at TEXT NOT NULL, + ended_at TEXT, + ref TEXT -- run id, PR number, package, etc. +); + +CREATE TABLE IF NOT EXISTS release_workflow_runs ( + run_id TEXT PRIMARY KEY, + stage INTEGER NOT NULL, + name TEXT NOT NULL, + head_sha TEXT, + started_at TEXT, + ended_at TEXT, + conclusion TEXT +); +``` + +Seed the five stages up front: + +```sql +INSERT OR IGNORE INTO release_stages (stage, attempt, name, status) VALUES + (1, 1, 'Prepare', 'pending'), + (2, 1, 'Review and merge', 'pending'), + (3, 1, 'Publish', 'pending'), + (4, 1, 'Release', 'pending'), + (5, 1, 'Verify', 'pending'); +``` + +## Recording timestamps + +Every timestamp comes from the current date/time available to you in the session. Use ISO-8601 local +time, for example `2026-08-04T13:22:05-07:00`. Never estimate a timestamp you could have recorded. + +**Prefer immutable external evidence over your own observation.** You notice things late; the event +itself has a real timestamp. Query it and use it: + +| Event | Authoritative source | +|---|---| +| PR merged | `gh pr view {n} --json mergedAt` | +| Release published | `gh release view v{version} --json publishedAt` | +| Workflow run start/end | `gh run view {id} --json startedAt,updatedAt,conclusion` | +| Commit created | the commit's author date | + +Recording stage 4's end from the moment you noticed publication, rather than from `publishedAt`, +inflates that stage by your entire polling interval. The same applies to a merge you detect on a +later poll, and to workflow runs you attach to after they started. + +- **Session start** -- write `session_started_at` into `release_session` at initialization. +- **Stage start** -- set `status = 'in_progress'` and `started_at` the moment you begin the stage's + first substantive action (invoking the skill, or beginning a status assessment for a human-gate + stage). +- **Stage end** -- set `status = 'done'` and `ended_at` the moment the stage's gate is satisfied + (PR opened, PR merged, draft created, release published, packages listed) -- **not** when the user + next speaks. +- **Blocked** -- set `status = 'blocked'` with a note when a stage cannot advance (red CI, an + unresolved breaking-change decision, a failed release workflow). Leave `started_at` intact; the + blocked span still counts toward that stage's wall-clock time. +- **Carried over** -- when resuming a release and evidence shows a stage completed in an earlier + session, record it as `status = 'carried_over'` with `started_at` and `ended_at` left NULL. Never + invent durations for work you did not observe. +- **Rework** -- when a stage that reached its gate has to be revisited (CI went red after the PR was + opened, a corrective push, a re-run of a failed workflow), close the current attempt and insert a + new row with `attempt + 1` rather than reopening the old one or stretching its `ended_at`. One + aggregate row per stage hides the shape of the time: a stage 2 that reads as "2h 22m" tells you + nothing about how much was CI, how much was review, and how much was remediation. + +## Recording waits + +Insert a `release_waits` row whenever you begin waiting on something that is not the user, and close +it when the wait ends. Cover child-session work, CI watches, workflow watches, and index polling. + +This is what makes the closing summary's split honest. Without it, wait time can only be inferred by +subtracting interaction time from stage wall-clock, which quietly counts discussion, diagnosis, and +rework as waiting. + +**A wait records unattended time only, so it must not overlap an interaction.** These two clocks run +in the same wall-clock window — a two-hour CI watch during which the user answers an eleven-minute +gate is not two hours of waiting plus eleven minutes of interaction. Counting both in full makes the +parts exceed the whole and drives the remainder negative: + +``` +total 120m − active 11m − waiting 120m = −11m +``` + +Keep them disjoint as you record, rather than reconciling later. When a wait is running and you turn +to the user, **close the wait, handle the interaction, then open a new wait row** for the remainder. +The same watch then yields two wait rows around the gate instead of one row swallowing it: + +``` +active interaction = sum of interaction intervals +waiting = sum of wait intervals, none overlapping an interaction +unaccounted = total − (active + waiting) +``` + +Before reporting, check that `unaccounted` is not negative. If it is, the rows overlap and the split +is wrong — say so and report the measured totals plainly instead of publishing a negative remainder +or clamping it to zero. A clamped number looks correct and hides the defect. + +Report the unaccounted remainder rather than distributing it. A visible gap is information; a +silently absorbed one is a wrong number. + +Record every CI and release workflow run in `release_workflow_runs` as you watch it, using the run's +own `startedAt` and `updatedAt`. This makes the longest-wait figure in the summary a lookup instead +of a recollection. These rows are evidence about the run itself, so they are exempt from the +non-overlap rule — never sum them into `waiting`. + +## Recording interactions + +Insert a `release_interactions` row every time you put a gate, question, or review in front of the +user: write `prompted_at` when you ask, and fill `answered_at` from the timestamp of their reply. + +**Close the open interaction before doing anything else with the user's reply.** At most one row per +stage should have a NULL `answered_at` at any moment -- the question you are currently waiting on. +When a reply arrives, your first action is to `UPDATE` that row with `answered_at` and `outcome`; +only then act on what they said. Deferring the update is how rows end up permanently NULL, because +by the time the work is done the arrival time is gone. + +```sql +UPDATE release_interactions +SET answered_at = '{reply-timestamp}', outcome = '{what they decided}' +WHERE id = (SELECT MAX(id) FROM release_interactions WHERE answered_at IS NULL); +``` + +Two failure modes to avoid, both of which produce numbers that look fine and are wrong: + +- **Never write `answered_at` equal to `prompted_at`.** A zero-duration interaction means the reply + timestamp was unavailable, not that the user answered instantly. Leave it NULL and count the row + as unmeasured. +- **Record choice-style prompts too.** A gate answered by picking an option is still interaction; if + the mechanism gives you no reply timestamp, log the row with NULL `answered_at` so it appears in + the unmeasured count rather than vanishing. + +At wrap-up, report how many interactions were measured and how many were not. That belongs in the +narrative prose, not in the timing table: "~27m across six gates, four more unmeasured" is an honest +floor, while the table's cells stay clean and carry only the `~` estimate marker. + +**Always set `stage` on the interaction row.** The closing summary reports interaction time per stage +alongside each stage's elapsed time, which is what makes the table actionable -- a 2h 22m stage +costing ~11m of your attention reads very differently from one costing ~2h. That roll-up is only +possible if every interaction is attributed when it is recorded: + +```sql +SELECT stage, + SUM(strftime('%s', answered_at) - strftime('%s', prompted_at)) AS measured_seconds, + SUM(answered_at IS NULL) AS unmeasured +FROM release_interactions +GROUP BY stage; +``` + +A stage whose interactions all lack a usable reply timestamp reports `—`, not `~0m`. `~0m` means the +stage had no interactions, or its measured intervals rounded to zero -- it asserts that the stage +cost the user no material time, which is a claim you can only make from data you actually have. + +The interval between `prompted_at` and `answered_at` is the user's **think-and-respond time**. Sum +those intervals to estimate **active user-interaction time**. Do not treat the rest of the session as +waiting by subtraction -- take waiting from `release_waits` and report the remainder as unaccounted. + +Apply judgement when summing: + +- Discard or cap any single interval that clearly represents the user stepping away rather than + engaging -- an overnight gap between a gate and its answer is wait time, not interaction time. + Note in the summary that such a gap was excluded. +- Long stretches where the user reviews a diff, release notes, or a PR **are** interaction time even + though you were idle. +- Always label the result as an estimate, and state the measured/unmeasured split alongside it. + +## Progress rail + +Render the rail from the latest attempt of each stage in `release_stages` at every gating prompt: + +``` +[✓] 1 Prepare → [●] 2 Review and merge → [ ] 3 Publish → [ ] 4 Release → [ ] 5 Verify +``` + +Use `✓` for done, `●` for in progress, `⚠` for blocked, `↩` for carried over, and a blank for +pending. Add the current sub-step after the rail when one is active, for example +`current: waiting on CI (2 checks running)`. diff --git a/.github/agents/release-manager/references/summary-template.md b/.github/agents/release-manager/references/summary-template.md new file mode 100644 index 000000000..966bbe15e --- /dev/null +++ b/.github/agents/release-manager/references/summary-template.md @@ -0,0 +1,108 @@ +# Release Wrap-Up Summary + +Present this summary when the release is complete: the GitHub release is published, both the release +and docs workflows have succeeded, the packages are listed on NuGet.org, and the docs site reflects +the release. + +The tone is short and celebratory. It is a chat message to the user -- **do not commit it, do not +post it to GitHub, and do not write it to a file** unless the user explicitly asks. + +Build the timing sections from the `release_stages`, `release_interactions`, `release_waits`, and +`release_workflow_runs` tables described in [session-tracking.md](session-tracking.md). + +## Template + +```markdown +🎉 **v{version} is released.** + +{One or two sentences on the release theme, echoing the preamble that shipped in the release notes.} + +**Shipped** + +| | | +|---|---| +| Version | `v{version}` | +| Base branch | `{base branch}` | +| Release PR | #{pr} | +| Release | {release URL} | +| Release workflow | {run URL} — {conclusion} | +| Docs workflow | {run URL} — {conclusion} | +| NuGet | {listed package versions, or the package listing URL} | +| Docs | https://csharp.sdk.modelcontextprotocol.io/{version-slug}/ — live | + +**Packages** + +* {package name} {version} +* {package name} {version} + +**Stage timing (this session)** + +| Stage | Status | Elapsed | Interactions | +|---|---|---|---| +| 1. Prepare | ✓ | {h m} | ~{h m} | +| 2. Review and merge | ✓ | {h m} | ~{h m} | +| 2. Review and merge (attempt 2) | ✓ | {h m} | ~{h m} | +| 3. Publish | ✓ | {h m} | ~{h m} | +| 4. Release | ✓ | {h m} | ~{h m} | +| 5. Verify | ✓ | {h m} | ~{h m} | +| **Total session** | | **{h m}** | **~{h m}** | + +{Include an attempt row only when a stage was reworked, and say what forced it -- "CI red, corrective +push". Aggregating rework into one row hides where the time actually went.} + +**Where the time went** + +* Active interaction — ~{h m} across {n} measured gates{, plus {n} unmeasured} +* Waiting on builds, CI, and the release and docs workflows — ~{h m} +* Unaccounted — {h m} +* Longest single wait — {h m} ({what you were waiting on}) + +{Optional: one line on anything notable — a blocked stage and how long it cost, an excluded +step-away gap, or a stage that ran unusually long or short.} + +**Follow-ups** + +* {Anything deferred during the release, or "None."} +* {Worktrees still on disk for this release, offered for cleanup, or omit this line.} +``` + +## Rules + +1. **Only report what you observed.** Stages recorded as `carried_over` show `↩ carried over from a + previous session` in the Status column and `—` for Elapsed. They are excluded from the total, and + a footnote says the total covers this session only. +2. **Total session** is wall-clock from `session_started_at` to now, not the sum of stage elapsed + times -- gaps between stages belong to the session but to no stage. +3. **The Interactions column is per-stage active user time.** Sum that stage's + `release_interactions` prompt-to-answer intervals and prefix with `~`: `~5m`, `~1h 3m`. Show + `~0m` when the stage had no interactions at all, or when its measured intervals round to zero. + Show `—` when the stage *did* have interactions but none of them carry a usable reply timestamp -- + that is missing data, not zero time, and must never be rendered as `~0m` or fabricated. + Carried-over stages show `—` in both time columns. +4. **`~` is the only qualifier the table needs.** Never append "minimum", "at least", or a similar + hedge to a cell -- the tilde already says the figure is estimated, and the table stays scannable. + When stages show `—` or interactions went unmeasured, explain that in the narrative prose below + rather than in the table. +5. **Active interaction time is always an estimate.** Label it with `~` and say it is estimated from + prompt-to-answer intervals. In the narrative, report it as a floor with the unmeasured count + beside it -- interactions whose reply timestamp was unavailable are counted, not silently dropped. + Name any interval you excluded as a step-away gap. +6. **Reconcile the narrative with the table.** The `Active interaction` bullet must equal the table's + total interaction cell. Where the two could differ -- excluded step-away gaps, `—` stages, + zero-duration rows discarded as unmeasured -- name the discrepancy explicitly rather than letting + the reader find it. +7. **Waiting time is measured, not inferred.** Sum the `release_waits` intervals. Never derive it by + subtracting interaction time from the session total; that counts diagnosis and rework as waiting. + Show whatever the two do not account for as `Unaccounted` rather than folding it into either. + **If `Unaccounted` computes negative, wait and interaction rows overlapped** — the split is + unsound, so omit the `Unaccounted` line, report the two measured totals, and state plainly that + they overlap. Never publish a negative figure and never clamp it to zero, which would present a + broken split as a clean one. +8. **Longest single wait comes from `release_waits` and `release_workflow_runs`**, not from the + longest interaction. If waits were not recorded, say the data is unavailable instead of + substituting the longest gate. +9. **Round to readable units.** `2h 14m`, `47m`, `3m`. Never show seconds. +10. **Omit rows and sections that do not apply.** No blocked stage means no note about one; no + follow-ups means the section says `None.` rather than disappearing. +11. **Never speculate about time.** If the session lacks the data for a section, say so plainly + instead of estimating. diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md index 1e48e167c..a8bb2d9a7 100644 --- a/.github/copilot-instructions.md +++ b/.github/copilot-instructions.md @@ -2,6 +2,25 @@ This repository contains the official C# SDK for the Model Context Protocol (MCP), enabling .NET applications to implement and interact with MCP clients and servers. +## GitHub Interactions + +### Commits and Pushes +- Never push to an active pull request without being explicitly asked. Always wait for explicit instructions to push. +- Never chain commit and push in the same command. Commit first, report what was committed, then wait for explicit push instructions. This creates a mandatory decision point. + +### AI-Generated Content Disclosure +When posting any content to GitHub under a user's credentials — opening pull requests, creating issues, commenting on pull requests or issues, posting review comments, or taking any other public-facing action — include a concise, visible note (e.g. a `> [!NOTE]` alert) at the bottom indicating that the content was AI/Copilot-generated. + +This disclosure is not required when: +- The account is a recognized bot or Copilot app account (for example, `github-actions[bot]` or `copilot`), where the AI origin is already apparent from the account identity. +- The user explicitly asks to omit the disclosure. + +**Draft release notes** are a special case. Include the disclosure while the release is a draft, but +remind the user at the publishing handoff that they may remove it once they have thoroughly reviewed +and signed off on the notes — the published notes then stand as their own reviewed work. Removing it +is always the user's decision; never remove it on your own initiative, and never reintroduce it once +the user has removed it. + ## Critical: Always Build and Test **ALWAYS build and run tests before declaring any task complete or making a pull request.** diff --git a/.github/release-process.md b/.github/release-process.md new file mode 100644 index 000000000..79a91d12f --- /dev/null +++ b/.github/release-process.md @@ -0,0 +1,52 @@ +# Release Process + +The following process is used when publishing new releases to NuGet.org. + +The [`release-manager`](agents/release-manager.agent.md) custom agent orchestrates this process end +to end -- routing to the `prepare-release` and `publish-release` skills, holding a human gate at each +stage, tracking how long each stage takes, and closing with a release summary. Start it with a +prompt like "Where are we in the release process?" or "Prepare a release." The steps +below remain the authoritative description of the process itself. + +## 1. Ensure the CI workflow is fully green + +- Some integration tests are flaky and may require re-running +- Once the state of the branch is known to be good, a release can proceed +- **The release workflow _does not_ run tests** — CI must be green before starting + +## 2. Prepare the release + +From a local clone of the repository, use Copilot CLI to invoke the `prepare-release` skill. The skill assesses the semantic version, bumps the version in [`src/Directory.Build.props`](../src/Directory.Build.props), runs API compatibility checks, reviews documentation, drafts release notes, and creates a pull request with all release artifacts. + +As part of Step 9 (documentation review), the skill also updates the shared embedded NuGet README (`src/PACKAGE.md`) -- adding any newly introduced packages to the package-list closure, applying the correct badge style (`nuget/vpre` for a prerelease series or `nuget/v` for a stable release), adding a release-notes link pointing to the tag being created, and syncing the same closure changes to the root `README.md`. + +Review the PR, request changes if needed, and merge when ready. + +## 3. Publish the release + +After the prepare-release PR is merged, invoke the `publish-release` skill. The skill checks for any late-arriving PRs that could affect the release, refreshes the release notes, re-runs the README content checklist (confirming package closure, badge style, and release-notes link), and creates a **draft** GitHub release. + +Review the draft release on GitHub, check 'Set as a pre-release' if appropriate, and click 'Publish release'. + +## Branching + +The `main` branch is the next-MAJOR preview and development line; currently, it produces the `2.0.0-preview.*` series. Nightly `cron` CI on `main` publishes CI-suffixed packages to GitHub Packages. +Long-lived `release/{MAJOR}.x` branches are created on demand when a shipped MAJOR needs servicing releases. Every push to a `release/*` branch publishes a CI-suffixed package to GitHub Packages, so servicing CI packages are commit-driven rather than clock-driven. +Short-lived `release-{version}` branches are local prepare-release work branches that become pull requests, such as `release-2.0.0-preview.1` or `release-1.3.1`. +Official NuGet.org publishes occur only when a GitHub Release is created from a branch's tag. +The prepare-release skill asks for the source/base branch first so the release PR targets the same line it assessed. +For the agent-facing, structured version of these rules, see [release-branches.md](skills/shared-resources/release-branches.md). + +## 4. Verify the release + +Publishing the release triggers two workflows in parallel. Invoke the `verify-release` skill to +monitor both and confirm their published outputs: + +- **Release** — produces build artifacts and publishes the NuGet packages to NuGet.org. If the job + fails, troubleshoot and re-run the workflow as needed. Verify the package version becomes listed + at [nuget.org/packages/ModelContextProtocol](https://www.nuget.org/packages/ModelContextProtocol). +- **[Publish Docs](workflows/docs.yml)** — rebuilds the versioned documentation site from the + published release tags and deploys it to + [csharp.sdk.modelcontextprotocol.io](https://csharp.sdk.modelcontextprotocol.io). Verify the new + version appears in the version picker and that its major-version path serves the updated content. + A content-only docs refresh can be run later via manual dispatch with the `docs_ref` input. diff --git a/.github/skills/breaking-changes/references/classification.md b/.github/skills/breaking-changes/references/classification.md index e58897214..9c34c3790 100644 --- a/.github/skills/breaking-changes/references/classification.md +++ b/.github/skills/breaking-changes/references/classification.md @@ -122,7 +122,7 @@ Before dismissing a potential break, review the PR description and all PR commen Every dismissed potential break must be reported to the user with enough detail for them to verify the conclusion. The audit must: 1. **Identify what would normally be breaking and why** (e.g., "CP0005 — adding abstract member `Completion` to abstract class `McpClient`") -2. **Explain the specific reason for dismissal** (e.g., "Bug fix correcting incorrect behavior per the MCP spec" or "`McpClient`'s only accessible constructor is `protected` and marked `[Experimental(MCPEXP002)]` with message 'Subclassing McpClient and McpServer is experimental and subject to change.'") +2. **Explain the specific reason for dismissal** (e.g., "Bug fix correcting incorrect behavior per the MCP spec" or "`McpClient`'s only accessible constructor is `protected` and marked `[Experimental(MCPEXP002)]` with message 'This C# SDK extensibility API is experimental and subject to change.'") 3. **Cite any supporting discussion** from the PR description or comments (e.g., "Reviewers discussed the addition and did not flag it as a breaking concern; compatibility suppressions were added for CP0005") 4. **Conclude with the dismissal and its category** (e.g., "Dismissed — bug fix correcting spec-non-compliant behavior" or "Dismissed — exclusively gated by `[Experimental]` API. Do not apply the `breaking-change` label.") diff --git a/.github/skills/bump-version/SKILL.md b/.github/skills/bump-version/SKILL.md index 29932b4db..1127aa284 100644 --- a/.github/skills/bump-version/SKILL.md +++ b/.github/skills/bump-version/SKILL.md @@ -8,18 +8,21 @@ compatibility: Requires gh CLI with repo access for creating branches and pull r Assess and bump the SDK version in `src/Directory.Build.props` to prepare for the next release. This skill owns the [Semantic Versioning 2.0.0](https://semver.org/spec/v2.0.0.html) assessment logic — the [SemVer assessment guide](references/semver-assessment.md) is the single source of truth for version assessment criteria used across the release workflow by both the **prepare-release** and **publish-release** skills. +Use the shared [release branch reference](../shared-resources/release-branches.md) for branch roles, previous-release lookup rules, and release work-branch naming. + > **Note**: For comprehensive release preparation — including ApiCompat/ApiDiff, documentation review, and release notes — use the **prepare-release** skill, which incorporates version assessment as part of its broader workflow. ## Process ### Step 1: Read Current Version and Previous Release -Read `src/Directory.Build.props` on the default branch and extract: +Read `src/Directory.Build.props` on the current branch and extract: - `` — the `MAJOR.MINOR.PATCH` version +- `` — the prerelease suffix, when present -Display the current version to the user. +The candidate version is `{VersionPrefix}` plus `-{VersionSuffix}` when the suffix is present (for example, `2.0.0-preview.1`). Display the current candidate version to the user. -Determine the previous release tag from `gh release list` (most recent **published** release). Draft releases must be ignored — they represent a pending release that has not yet shipped. Use `--exclude-drafts` or filter to only published releases when querying. +Determine the previous release tag from `gh release list` — the **highest semver** among published releases that are ancestors of the target commit, not the most recently published by date. Draft releases must be ignored — they represent a pending release that has not yet shipped. Use `--exclude-drafts` or filter to only published releases when querying. The lookup is branch-aware: from a `release/{MAJOR}.x` branch, restrict candidates to tags matching `v{MAJOR}.*`; from `main`, there is no MAJOR filter. See [release-branches.md](../shared-resources/release-branches.md#previous-release-tag-lookup) for details, including why date ordering picks the wrong tag. ### Step 2: Assess and Determine Next Version @@ -40,26 +43,31 @@ When context about queued changes is available or can be gathered, assess the ve #### Default Suggestion (Fallback) -When a quick bump is needed without full change analysis, suggest the next **minor** version: +When a quick bump is needed without full change analysis, suggest based on the candidate version: -- Current `1.0.0` → suggest `1.1.0` -- Current `1.2.3` → suggest `1.3.0` +- **Stable candidate** — suggest the next **minor** version: + - Current `1.0.0` → suggest `1.1.0` + - Current `1.2.3` → suggest `1.3.0` +- **Prerelease candidate** — if the suffix starts with an identifier such as `preview.` or `rc.` followed by an integer, suggest incrementing the trailing integer: + - Current `2.0.0-preview.1` → suggest `2.0.0-preview.2` + - Current `2.0.0-rc.1` → suggest `2.0.0-rc.2` Present the suggestion and let the user confirm or provide an alternative. -Parse the confirmed version into its `VersionPrefix` component. +Parse the confirmed version into its `VersionPrefix` and `VersionSuffix` components. Stable versions have no suffix. ### Step 3: Create Pull Request -1. Create a new branch named `bump-version-to-{version}` (e.g. `bump-version-to-1.1.0`) from the default branch +1. Create a new branch named `bump-version-to-{version}` (e.g. `bump-version-to-1.1.0`) from the current branch 2. Update `src/Directory.Build.props`: - - Set `` to the new version + - Set `` to the confirmed stable component + - Set `` for prerelease versions, or clear it for stable versions; add the element if it is missing - Update `` if the MAJOR version has changed 3. Commit with message: `Bump version to {version}` 4. Push the branch and create a pull request: - **Title**: `Bump version to {version}` - **Label**: `infrastructure` - - **Base**: default branch + - **Base**: the current branch (which, for a servicing branch like `release/1.x`, is that servicing branch — not `main`) ### Step 4: Confirm diff --git a/.github/skills/bump-version/references/semver-assessment.md b/.github/skills/bump-version/references/semver-assessment.md index 2d39ec166..3d149780a 100644 --- a/.github/skills/bump-version/references/semver-assessment.md +++ b/.github/skills/bump-version/references/semver-assessment.md @@ -56,13 +56,31 @@ Recommend a PATCH version increment if no MAJOR or MINOR criteria are met. - MINOR: `MAJOR.(MINOR+1).0` - PATCH: `MAJOR.MINOR.(PATCH+1)` -**Examples** from previous release `v1.2.0`: +### Prereleases -| Level | Recommended | -|-------|-------------| -| PATCH | `v1.2.1` | -| MINOR | `v1.3.0` | -| MAJOR | `v2.0.0` | +While the candidate version uses a prerelease suffix (e.g., `X.Y.Z-preview.N`, `X.Y.Z-rc.N`), the recommended next version increments the trailing integer of the suffix: `preview.3` → `preview.4`, `rc.1` → `rc.2`. + +Going to GA drops the suffix entirely: `2.0.0-rc.2` → `2.0.0`. + +This is purely about how to *compute* the next version. It does **not** declare any new policy about what kinds of changes are permitted between previews — refer to the existing [versioning documentation](../../../../docs/versioning.md) for breaking-change policy. + +### Branch context + +The "previous release" lookup selects the highest semver among published releases that are ancestors of the target commit, constrained to tags matching `v{MAJOR}.*` when assessing from a `release/{MAJOR}.x` servicing branch. On `main`, there is no MAJOR filter. It is not a date-ordered lookup; see [release-branches.md](../../shared-resources/release-branches.md#previous-release-tag-lookup). + +The MAJOR/MINOR/PATCH classification criteria above are unchanged regardless of branch. + +See [release-branches.md](../../shared-resources/release-branches.md) for branch-role definitions and previous-release lookup rules. + +**Examples**: + +| Previous release | Branch | Level | Recommended | +|--------------------|---------------|-----------------------|------------------------| +| `v1.2.0` | `main` | PATCH | `v1.2.1` | +| `v1.2.0` | `main` | MINOR | `v1.3.0` | +| `v1.2.0` | `main` | MAJOR | `v2.0.0` | +| `v2.0.0-preview.1` | `main` | (prerelease bump) | `v2.0.0-preview.2` | +| `v1.3.0` | `release/1.x` | PATCH | `v1.3.1` | ## Comparing Against the Candidate Version @@ -83,6 +101,7 @@ Present the assessment as a summary table followed by a rationale: | Aspect | Finding | |--------|---------| +| Branch context | release/1.x | | Previous release | v1.0.0 | | Breaking changes | None confirmed | | New API surface | Yes — 3 PRs add new public APIs | diff --git a/.github/skills/prepare-release/SKILL.md b/.github/skills/prepare-release/SKILL.md index 03976ac91..5e66a1637 100644 --- a/.github/skills/prepare-release/SKILL.md +++ b/.github/skills/prepare-release/SKILL.md @@ -12,22 +12,72 @@ Prepare a new release for the `modelcontextprotocol/csharp-sdk` repository. This > **User confirmation required: This skill NEVER pushes a branch or creates a pull request without explicit user confirmation.** The user must review and approve all details before any remote operations occur. +Use the shared [release branch reference](../shared-resources/release-branches.md) for branch roles, previous-release lookup rules, and release work-branch naming. + ## Process Work through each step sequentially. Present findings at each step and get user confirmation before proceeding. Skip any step that has no applicable items. -### Step 1: Determine Target and Gather PRs +### Step 0: Sync With Upstream + +Every later step reads branches, tags, and file contents from the local repository. Stale local refs +produce assessments that are wrong in ways that look plausible: a missing tag makes a released +version invisible, and a stale branch hides merged PRs. Establish a complete, current view before +reading anything. + +1. Identify the remote that points at the canonical repository (`modelcontextprotocol/csharp-sdk`). + Do not assume it is named `origin` — in a fork-based checkout `origin` is often the fork: + `git remote -v` +2. Fetch that remote's branches **and tags**, pruning deleted refs: + `git fetch {upstream} --prune --prune-tags --tags` +3. Confirm the tag for the most recent published release exists locally and resolves: + `git rev-parse --verify v{previous}^{commit}` + +Report what changed as a result of the fetch — new tags, updated branch heads — so the user can see +whether the starting state was stale. + +Read every subsequent step's branch state from the remote-tracking refs (`{upstream}/main`, +`{upstream}/release/{MAJOR}.x`), not from local branches, which may lag or have diverged. + +### Step 1: Select Source Branch + +List candidate source/base branches via: +`gh api repos/{owner}/{repo}/branches --paginate --jq '[.[] | select(.name == "main" or (.name | startswith("release/"))) | .name]'` + +Present the list to the user and ask them to choose the source/base branch. Default selection: `main`. + +The selected branch drives every subsequent step: +1. The branch on which the candidate version is read from `src/Directory.Build.props`. +2. The "previous release" lookup (constrained to `v{MAJOR}.*` on `release/{MAJOR}.x`). +3. The commit range from which PRs are collected. +4. The PR base (`--base`) for `gh pr create` at the end of the skill. + +See [release-branches.md](../shared-resources/release-branches.md) for the structured branch rules. + +### Step 2: Determine Target and Gather PRs The user may provide: -- **A git ref** (commit SHA, branch, or tag) — use as the target commit -- **No context** — show the last 5 commits on `main` (noting HEAD) and offer the option to enter a branch or tag name instead +- **A git ref** (commit SHA, branch, or tag) — use as the target commit relative to the selected source/base branch +- **No context** — show the last 5 commits on the selected source/base branch (noting HEAD) and offer the option to enter a branch or tag name instead Once the target is established: -1. Determine the previous release tag from `gh release list` (most recent **published** release — exclude drafts with `--exclude-drafts`). -2. Get the full list of PRs merged between the previous release tag and the target commit. -3. Read `src/Directory.Build.props` **at the target commit**. Extract `` as the **candidate version**. +1. Determine the previous release tag from `gh release list` — the **highest semver** among published releases that are ancestors of the target commit (exclude drafts with `--exclude-drafts`). Do not order by publication date; see [release-branches.md](../shared-resources/release-branches.md#previous-release-tag-lookup) for why the two differ and what breaks. On `release/{MAJOR}.x`, restrict candidates to tags matching `v{MAJOR}.*`; on `main`, there is no MAJOR filter. +2. Get the full list of PRs merged between the previous release tag and the target commit on the selected branch. +3. Read `src/Directory.Build.props` **at the target commit**. Extract `` and ``; the **candidate version** is `{VersionPrefix}` plus `-{VersionSuffix}` when the suffix is present (for example, `2.0.0-preview.1`). +4. **Verify the previous release tag is an ancestor of the target commit:** + `git merge-base --is-ancestor v{previous} {target}` -### Step 2: Categorize and Attribute + If it is not an ancestor, stop and report. The two histories have diverged, which means the + selected source branch is not a continuation of the previous release. Every downstream + conclusion would be wrong: the PR range would be computed across unrelated history, and the + ApiCompat baseline in Step 7 would report the previous release's entire API surface as removed. + This is a source-selection problem, not a compatibility problem — do not attempt to suppress it. + + The usual cause is that the previous release shipped from a different branch than the one + selected. Re-run Step 1 and choose the branch that actually contains the previous release, or + confirm with the user that a divergent source is intended and why. + +### Step 3: Categorize and Attribute Sort every PR into one of four categories. See [references/categorization.md](references/categorization.md) for detailed guidance. @@ -50,53 +100,63 @@ Sort every PR into one of four categories. See [references/categorization.md](re - Omit the co-author parenthetical when there are none - Sort entries within each section by merge date (chronological) -### Step 3: Breaking Change Audit +### Step 4: Breaking Change Audit Invoke the **breaking-changes** skill with the commit range from the previous release tag to the target commit. Examine every PR, assess impact, reconcile labels (offering to add/remove labels and comment on PRs), and get user confirmation. Use the results (confirmed breaking changes with impact ordering and detail bullets) in the remaining steps. -### Step 4: Assess Release Version +### Step 5: Assess Release Version -Using the categorized PRs from Step 2 and confirmed breaking changes from Step 3, assess the appropriate [Semantic Versioning 2.0.0](https://semver.org/spec/v2.0.0.html) release level. Follow the [SemVer assessment guide](../bump-version/references/semver-assessment.md) (owned by the **bump-version** skill) for the full assessment criteria. +Using the categorized PRs from Step 3 and confirmed breaking changes from Step 4, assess the appropriate [Semantic Versioning 2.0.0](https://semver.org/spec/v2.0.0.html) release level. Follow the [SemVer assessment guide](../bump-version/references/semver-assessment.md) (owned by the **bump-version** skill) for the full assessment criteria. 1. **Classify the release level**: - **MAJOR** — if any confirmed breaking changes are present (API or behavioral), excluding changes to `[Experimental]` APIs - **MINOR** — if no breaking changes but new public APIs, features, or obsoletion warnings are introduced - **PATCH** — otherwise -2. **Compute the recommended version** from the previous release tag: +2. **Compute the recommended version** from the previous release tag and branch context: - Increment the appropriate component (MAJOR resets MINOR.PATCH to 0; MINOR resets PATCH to 0) + - For prerelease candidates such as `preview.N` or `rc.N`, the recommendation may simply increment the trailing integer per the assessment guide 3. **Compare against the candidate version** from `src/Directory.Build.props`. Flag any discrepancy: - **Under-versioned**: The candidate is lower than the recommended level. This is a concern that should be resolved. - **Over-versioned**: The candidate is higher than strictly required. This is acceptable under SemVer but worth noting. 4. **Present the assessment** with a summary table showing the previous release, change classification, recommended level, recommended version, and any discrepancy with the candidate. Include a brief rationale citing the most significant PRs. 5. **Get user confirmation** of the release version before proceeding. -### Step 5: Create Release Branch and Bump Version +### Step 6: Create Release Branch and Bump Version After the version is confirmed: -1. Create a local branch named `release-{version}` from the target commit (e.g., `release-1.1.0`). +1. Create a local branch named `release-{version}` from the target commit (e.g., `release-2.0.0-preview.1`, `release-1.3.1`). 2. Update `src/Directory.Build.props`: - - Set `` to the confirmed version - - Update `` if the MAJOR version has changed (set to the previous release version) + - Set `` to the confirmed stable component + - Set `` for prerelease versions, or clear it for stable versions; add the element if it is missing + - Update `` when appropriate, per the rule in [references/apicompat-apidiff.md](references/apicompat-apidiff.md#updating-the-baseline-version). Read the current value from `src/Directory.Build.props` and derive the correct one from the versions actually published; never copy a version from an example. Show the derivation — current value, published versions considered, resulting value, and whether it changes — and get confirmation before editing. **If the value changes, the [baseline-transition suppression audit](references/apicompat-apidiff.md#baseline-transition-suppression-audit) is mandatory.** 3. Build the solution to verify the version change compiles: `dotnet build` This step creates local changes only — nothing is committed or pushed yet. -### Step 6: Run API Compatibility Check +### Step 7: Run API Compatibility Check Run API compatibility validation against the baseline version. Follow [references/apicompat-apidiff.md](references/apicompat-apidiff.md) for the full procedure. 1. Run `dotnet pack` to trigger package validation against `PackageValidationBaselineVersion` 2. Capture the ApiCompat output (compatibility issues, warnings, suppressions) -3. If there are unexpected compatibility breaks: - - Cross-reference with the breaking change audit from Step 3 +3. **If `PackageValidationBaselineVersion` changed in this release, run the baseline-transition suppression audit before interpreting anything else.** Moving the baseline makes suppressions written for the old baseline stale, and the resulting failure looks exactly like a mass breaking change. +4. If there are unexpected compatibility breaks: + - **First, check whether the output says `Unnecessary suppressions found`.** That is a hard failure in its own right, and the CP0001/CP0002/CP0005 lines beneath it are the listing of *unused suppression entries*, not live API breaks. Regenerate the suppression file and cross-check the API diff before believing them. + - **Then sanity-check the scale.** A large number of errors reporting *missing* API surface — + especially spanning whole feature areas — almost always means the baseline does not belong to + this branch's history, or that stale suppressions are being listed. Re-verify the ancestry check + from Step 2 before interpreting a single error. Never suppress your way out of this. + - Cross-reference with the breaking change audit from Step 4 - Present any unaccounted breaks to the user - - If breaks are intentional, add appropriate entries to `CompatibilitySuppressions.xml` in the affected project directory -4. Record the ApiCompat results for inclusion in the PR description + - If breaks are intentional, add appropriate entries to `CompatibilitySuppressions.xml` in the affected project directory — only after the suppression audit is complete +5. **Never adjust the thing being validated against in order to pass.** Do not change `PackageValidationBaselineVersion` to silence errors, do not set `ApiCompatPermitUnnecessarySuppressions`, do not `NoWarn` CP diagnostics, and do not disable package validation. The baseline is determined by what shipped; suppressions record user-confirmed intentional breaks. If validation fails unexpectedly, stop and report. +6. Confirm the plain CI-equivalent run passes with no generation flags: `dotnet clean -c Release; dotnet pack -c Release` +7. Record the per-package ApiCompat results — baseline, generated entry count, retained/removed suppressions, plain pack result — for Step 12 and the PR description -### Step 7: Generate API Diff Report +### Step 8: Generate API Diff Report Generate a human-readable diff of the public API surface between the previous release and the new version. Follow [references/apicompat-apidiff.md](references/apicompat-apidiff.md) for the full procedure, including how to install the `Microsoft.DotNet.ApiDiff.Tool` from the .NET transport feed. @@ -107,36 +167,92 @@ Generate a human-readable diff of the public API surface between the previous re > **If the ApiDiff tool cannot be installed or fails to produce output, STOP and inform the user.** Present the error and ask how to proceed. Do not fall back to a manual summary — the user must decide whether to troubleshoot, skip the API diff, or abort. -### Step 8: Review and Update Documentation +### Step 9: Review and Update Documentation Review repository documentation for changes needed to compensate for or adapt to this release: -1. **NuGet package READMEs** — Validate that code samples in `README.md` and `src/PACKAGE.md` compile against the current SDK. Follow [references/readme-snippets.md](references/readme-snippets.md) for the validation procedure. Propose fixes for any API mismatches. -2. **Conceptual documentation** — Review `docs/` for content affected by the changes in this release. Update references to changed APIs, new features, or removed functionality. -3. **Versioning documentation** — If the release introduces new versioning-relevant policies (new experimental APIs, obsoletion changes), verify `docs/versioning.md` reflects them. -4. **Changelogs** — If the repository contains changelog files (e.g., `CHANGELOG.md`), update them with the release information. If no changelogs exist, skip this sub-step and note it in the summary. +1. **NuGet package READMEs** -- Run the README content checklist from [references/readme-content.md](references/readme-content.md) and validate code samples: + a. **Content checklist** -- Open `src/PACKAGE.md` and verify each item in the checklist: + - **Package-list closure**: every shipping SDK package is listed. If a new package was introduced in this release, add it now. Use non-counting phrasing -- do not say "N main packages". + - **Badge strategy**: all package badges use `nuget/vpre` for a prerelease series or `nuget/v` for a stable release. Switch all badges together if the release type has changed. + - **Release-notes link**: add or update the link to `https://github.com/modelcontextprotocol/csharp-sdk/releases/tag/v{version}` for the confirmed release version. The tag does not yet exist at prepare time; the link is forward-referencing and resolves when the GitHub release is published. + - **Root README.md sync**: mirror any package-list closure changes in the root `README.md`. + - **Other salient content**: descriptions, getting-started links, version-specific notes. + b. **Snippet validation** -- Validate that `csharp`-fenced code blocks in `src/PACKAGE.md` and `README.md` compile against the current SDK. Follow [references/readme-snippets.md](references/readme-snippets.md) for the full procedure. Propose fixes for any API mismatches. +2. **Conceptual documentation** -- Review `docs/` for content affected by the changes in this release. Update references to changed APIs, new features, or removed functionality. +3. **Versioning documentation** -- If the release introduces new versioning-relevant policies (new experimental APIs, obsoletion changes), verify `docs/versioning.md` reflects them. +4. **Changelogs** -- If the repository contains changelog files (e.g., `CHANGELOG.md`), update them with the release information. If no changelogs exist, skip this sub-step and note it in the summary. Stage all documentation changes for inclusion in the release commit. -### Step 9: Draft Release Notes +**Edge Cases for README updates:** +- **New package introduced** -- Add it to the package-list closure in `src/PACKAGE.md` and `README.md`. Use the package's `` from its `.csproj` as the short description. +- **Release type changes (prerelease to stable or vice versa)** -- Switch all package badges between `nuget/vpre` and `nuget/v` together. +- **Release tag does not yet exist at prepare time** -- The release-notes link is forward-referencing; it is verified to resolve during the publish-release step. + +### Step 10: Draft Release Notes Compose the release notes that will appear in the PR description and serve as the foundation for the **publish-release** skill. This is a draft — the final release notes will be refreshed when the GitHub release is created. 1. **Preamble** — Draft a short paragraph summarizing the release theme. Present it to the user for review and editing. The preamble is **required**. -2. **Breaking Changes** — sorted most → least impactful (from Step 3 results). Include the versioning docs link. +2. **Breaking Changes** — sorted most → least impactful (from Step 4 results). Include the versioning docs link, using the `v{MAJOR}` slug for the version being released — see [release-branches.md](../shared-resources/release-branches.md#versioning-documentation-links). 3. **What's Changed** — chronological; includes breaking change PRs 4. **Documentation Updates** — chronological 5. **Test Improvements** — chronological 6. **Repository Infrastructure Updates** — chronological 7. **Acknowledgements**: - New contributors (first contribution in this release) - - Issue reporters (cite resolving PRs) + - Issue reporters (cite resolving PRs) — **excluding maintainers**. Acknowledgements exist to + thank the community; a maintainer filing an issue in their own repository is ordinary + project work, not a contribution to credit. Determine maintainer status via + `gh api repos/{owner}/{repo}/collaborators/{user}/permission --jq .permission` and omit + anyone with `admin` or `write`. Maintainers still appear in the reviewers bullet. - PR reviewers (single bullet, sorted by review count, no count shown) -8. **Full Changelog** link +8. **Full Changelog** link using the exact tag, including any suffix (for example, `v1.3.1` or `v2.0.0-preview.1`) -Omit empty sections. Present each section for user review before proceeding. +Omit empty sections. Present each section for user review before proceeding. Tag references in templates use `v{version}` exactly, including prerelease suffixes; the Full Changelog link compares the previous tag to the suffixed tag when applicable. -### Step 10: Commit Changes +### Step 10b: Review Categorization and Acknowledgements With the User + +**Do this before committing, and never defer it to the Step 12 summary.** Showing the finished +notes is not a substitute for this step. A complete, well-formatted set of release notes reads as +correct and does not invite scrutiny; users routinely approve it and then find miscategorized +entries afterward, once the PR is already open. Ask targeted questions while the answers are still +cheap to apply. + +Present two compact review artifacts and stop for a response after each. + +**1. Categorization table.** Every PR, its assigned section, and the reason — not just the +borderline ones, since the user cannot correct a call they were not shown: + +| PR | Title | Section | Why | +|---|---|---|---| +| #{number} | {title} | {section} | {what the placement turned on} | + +Then explicitly surface the judgment calls, naming the PRs and the reasoning that made each one +close: + +> These were the close calls: {PRs} touch code but not shipped packages, so I placed them under +> {section}. Any of these belong in a different section? + +Flag as a close call any PR that touches `samples/` or `tests/` but not `src/`, any PR placed in +"What's Changed" whose changes are confined to non-shipping paths, and any PR whose title suggests +a different section than the one you assigned. + +**2. Acknowledgements roster.** Each person, why they are listed, and their maintainer status: + +| Person | Reason | Maintainer? | +|---|---|---| +| @{handle} | {contribution or issue, and the PR that resolved it} | {yes/no — if yes, omit per Step 10 item 7} | + +Show entries you excluded and why, so the user can overrule the omission. Ask directly whether the +remaining list is right, since acknowledgement errors are about people and are the least +comfortable thing to correct after publication. + +Apply any corrections before Step 11. Record what changed so the same misclassification is not +reintroduced when publish-release refreshes the notes for late-arriving PRs. + +### Step 11: Commit Changes Commit all changes to the `release-{version}` branch: @@ -144,66 +260,93 @@ Commit all changes to the `release-{version}` branch: 2. Commit with message: `Prepare release v{version}` 3. Do **not** push yet -### Step 11: Present Release Summary +### Step 12: Present Release Summary -Present **all** of the following details to the user for review. The user must confirm every aspect before proceeding to Step 12. +Present **all** of the following details to the user for review. The user must confirm every aspect before proceeding to Step 13. 1. **Version number** with brief rationale for why this SemVer level was selected -2. **Branch name** (e.g., `release-1.1.0`) -3. **Remote** the branch would be pushed to (show the configured remote, typically `origin`) -4. **Files changed** — list every file modified in the commit with a one-line summary of what changed in each: +2. **Source/base branch** selected in Step 1 +3. **Branch name** (e.g., `release-2.0.0-preview.1`, `release-1.3.1`) +4. **Remote** the branch would be pushed to (show the configured remote, typically `origin`) +5. **Files changed** — list every file modified in the commit with a one-line summary of what changed in each: ``` - src/Directory.Build.props — Version bumped from 1.0.0 to 1.1.0 + src/Directory.Build.props — Version bumped from 2.0.0-preview.1 to 2.0.0-preview.2 src/ModelContextProtocol.Core/CompatibilitySuppressions.xml — Added 2 new suppressions README.md — Updated code sample for new API docs/experimental.md — Added new experimental API reference ``` -5. **Draft release notes** — the complete release notes from Step 9 -6. **API Compatibility results** — the ApiCompat output from Step 6 -7. **API Diff report** — the API diff from Step 7 -8. **Proposed PR title** (e.g., `Release v1.1.0`) -9. **Proposed PR description** — the assembled content combining release notes, ApiCompat, and ApiDiff +6. **Draft release notes** — the complete release notes from Step 10 +7. **API Compatibility results** — the per-package table from Step 7: baseline version, generated suppression count, retained/removed stale suppressions, and plain-pack result. Do not state that ApiCompat passed without these. Call out any change to `PackageValidationBaselineVersion` or to any suppression file explicitly. +8. **API Diff report** — the API diff from Step 8 +9. **Proposed PR title** (e.g., `Release v2.0.0-preview.1`, `Release v1.3.1`) +10. **Proposed PR description** — the assembled content combining release notes, ApiCompat, and ApiDiff After presenting all details, explicitly ask the user: > Would you like to push the branch and create the pull request? +Confirm the Step 10b review actually happened before asking. If categorization and acknowledgements +were never reviewed as their own decisions, go back and do that first — this gate is about +publishing mechanics, and burying content questions in it is how miscategorized entries reach an +open PR. + **Do not proceed without explicit "yes" confirmation.** -### Step 12: Push Branch and Create Pull Request +### Step 13: Push Branch and Create Pull Request -Only after explicit user confirmation in Step 11: +Only after explicit user confirmation in Step 12: 1. Push the `release-{version}` branch to the remote -2. Create a pull request: +2. Create a pull request with `gh pr create --base {step-1-branch}`: - **Title**: `Release v{version}` - - **Base**: default branch (typically `main`) + - **Base**: the source/base branch selected in Step 1 - **Head**: `release-{version}` - **Description**: The assembled PR description (see PR Description Template below) - **Labels**: Apply appropriate labels (e.g., `release`) 3. Present the PR URL to the user +4. **Monitor CI to completion.** Creating the PR does not end this step. Watch every check on the new head SHA until it reaches a terminal state: + ```sh + gh pr checks {pr-number} --watch + ``` + Then report a per-check table and an overall verdict of **green**, **running**, or **blocked**. Do not hand off with only the PR URL and an invitation to review — the user should not be the one to discover a red build. +5. **On failure**, retrieve the logs yourself (`gh run view {run-id} --log-failed`), distinguish product/API validation failures from infrastructure or tooling flakiness, and diagnose before proposing a rerun. For ApiCompat failures, apply the interpretation rules in [references/apicompat-apidiff.md](references/apicompat-apidiff.md) before concluding the release is breaking. Present the diagnosis and a proposed fix, then stop — pushing a fix needs the same explicit approval as the original push. +6. **Restart monitoring after every subsequent push** to the release branch, against the new head SHA. Checks from a previous SHA are stale and must not be reported as current. **Important**: No draft GitHub release is created at this point. The **publish-release** skill handles release creation after this PR is merged. ## Edge Cases -- **PR spans categories**: categorize by primary intent +- **PR spans categories**: categorize by primary intent, and surface it as a close call at Step 10b +- **PR adds sample code or tests but no `src/` changes**: Documentation Updates or Test Improvements, not "What's Changed" — the shipped packages did not change +- **Issue reporter is a maintainer**: omit the acknowledgement; show it as an exclusion at Step 10b so the user can overrule +- **User recategorizes after the PR is open**: update the PR body, and record the correction so publish-release does not re-derive the original category - **Copilot timeline missing**: fall back to `Co-authored-by` trailers to determine whether `@Copilot` should be a co-author; if still unclear, use `@Copilot` as primary author - **No breaking changes**: omit the Breaking Changes section from release notes entirely - **Single breaking change**: use the same numbered format as multiple - **No user-facing changes**: if all PRs are documentation, tests, or infrastructure, flag that a release may not be warranted and ask the user whether to proceed - **Version discrepancy**: if the candidate version from `Directory.Build.props` doesn't match the SemVer assessment, present the discrepancy and let the user decide the final version +- **Proposed MAJOR does not match branch MAJOR**: if the proposed version's MAJOR doesn't match the branch's MAJOR (for example, proposing `2.0.0-preview.2` on `release/1.x`), flag this as a warning and ask the user to confirm. Do not hard-fail. This is informational, not a policy enforcement. +- **Prerelease bump**: when the candidate version has a suffix like `preview.N`, the SemVer assessment may simply increment `N` rather than computing MAJOR/MINOR/PATCH. Refer to the SemVer assessment guide's Prereleases section. - **No previous release**: if this is the first release, there is no previous tag; gather all PRs merged to the target +- **Previous release tag is not an ancestor of the target**: stop and re-select the source branch per Step 2. Do not compute a PR range or interpret ApiCompat results across divergent history, and do not suppress the resulting errors +- **Previous release tag missing locally**: re-run the Step 0 fetch with `--tags` before concluding the release does not exist; a tag absent locally is far more often a stale checkout than an unpublished release - **ApiCompat tooling unavailable**: fall back to `dotnet pack` output; note in the PR description that full ApiCompat was run via package validation only +- **`Unnecessary suppressions found` in ApiCompat output**: the CP lines that follow are unused suppression entries, not live breaks. Run the baseline-transition suppression audit and cross-check the API diff before treating the release as breaking +- **Baseline version changed during preparation**: run the suppression audit for every shipping package, and decide deliberately between advancing the baseline (clearing stale suppressions) and keeping the existing one. Report the choice and its rationale at Step 12 +- **ApiCompat passes locally but CI fails**: check whether local runs used generation flags. Only `dotnet clean -c Release; dotnet pack -c Release` reproduces CI +- **A check never starts**: a workflow skipped by a path filter or stuck in a queue is not a pass. Compare against the check set on previous release PRs before declaring green +- **Checks green on an earlier SHA**: stale. Re-watch against the current head after every push +- **CI fails for infrastructure reasons**: a single rerun is reasonable if the cause is clearly runner, network, or feed related. State the reason. Never rerun a product or API validation failure to make it disappear - **API diff tool installation fails**: do not fall back to a manual summary; pause and present the installation error to the user, offering options to troubleshoot, skip the API diff section, or abort the release preparation - **No changelogs in repo**: skip changelog updates; note in the summary - **Branch already exists**: if `release-{version}` already exists locally or remotely, ask the user whether to reuse it, delete and recreate, or choose a different name -- **PackageValidationBaselineVersion update**: when bumping MAJOR version, update the baseline to the previous release version; when bumping MINOR or PATCH, keep the existing baseline -- **CompatibilitySuppressions.xml**: when intentional breaks are found, add suppression entries and include the file in the commit; existing suppressions should be preserved -- **User declines PR creation**: if the user declines at Step 11, leave the local branch intact so they can review, modify, or push manually +- **PackageValidationBaselineVersion update**: derive it per [references/apicompat-apidiff.md](references/apicompat-apidiff.md#updating-the-baseline-version) from the versions actually published, and show the derivation for confirmation. A change to this property makes the baseline-transition suppression audit mandatory +- **CompatibilitySuppressions.xml**: when intentional breaks are found, add suppression entries and include the file in the commit. Preserve existing suppressions **unless the baseline moved** — the audit may prove tracked entries stale, in which case removing them is the fix, not a regression +- **Versioning link for a brand-new MAJOR**: the `/v{MAJOR}/versioning.html` path does not exist until the release is published and the Publish Docs workflow runs. The link is forward-referencing at prepare time, like the release-notes tag link. Use the slugged form anyway; do not fall back to the unslugged URL. +- **User declines PR creation**: if the user declines at Step 12, leave the local branch intact so they can review, modify, or push manually ## PR Description Template -The PR description combines release notes, ApiCompat, and ApiDiff into a single document. Omit empty sections. +The PR description combines release notes, ApiCompat, and ApiDiff into a single document. Omit empty sections. The `{version}` placeholder is the full version and may include a prerelease suffix (for example, `Release v2.0.0-preview.1`). ```markdown # Release v{version} @@ -214,7 +357,7 @@ The PR description combines release notes, ApiCompat, and ApiDiff into a single ### Breaking Changes -Refer to the [C# SDK Versioning](https://csharp.sdk.modelcontextprotocol.io/versioning.html) documentation for details on versioning and breaking change policies. +Refer to the [C# SDK Versioning](https://csharp.sdk.modelcontextprotocol.io/v{MAJOR}/versioning.html) documentation for details on versioning and breaking change policies. 1. **Description #PR** * Detail of the break @@ -241,7 +384,8 @@ Refer to the [C# SDK Versioning](https://csharp.sdk.modelcontextprotocol.io/vers * @user made their first contribution in #PR * @user1 @user2 @user3 reviewed pull requests -**Full Changelog**: https://github.com/modelcontextprotocol/csharp-sdk/compare/previous-tag...release-{version} +**Full Changelog**: https://github.com/modelcontextprotocol/csharp-sdk/compare/{previous-tag}...v{version} + --- @@ -266,16 +410,16 @@ Refer to the [C# SDK Versioning](https://csharp.sdk.modelcontextprotocol.io/vers ## Release Notes Template -The release notes section within the PR description uses the same format as the final GitHub release notes (used by the **publish-release** skill). This ensures consistency between the PR and the published release. +The release notes section within the PR description uses the same format as the final GitHub release notes (used by the **publish-release** skill). This ensures consistency between the PR and the published release. Tag examples such as `v2.0.0-preview.1` are valid and should be used verbatim when the version has a prerelease suffix. -Omit empty sections. The preamble is **always required** — it is not inside a section heading. +Omit empty sections. The preamble is **always required** — it is not inside a section heading. The versioning link uses the `v{MAJOR}` slug for the version being released — see [release-branches.md](../shared-resources/release-branches.md#versioning-documentation-links). ```markdown [Preamble — REQUIRED. Summarize the release theme.] ## Breaking Changes -Refer to the [C# SDK Versioning](https://csharp.sdk.modelcontextprotocol.io/versioning.html) documentation for details on versioning and breaking change policies. +Refer to the [C# SDK Versioning](https://csharp.sdk.modelcontextprotocol.io/v{MAJOR}/versioning.html) documentation for details on versioning and breaking change policies. 1. **Description #PR** * Detail of the break @@ -303,5 +447,6 @@ Refer to the [C# SDK Versioning](https://csharp.sdk.modelcontextprotocol.io/vers * @user submitted issue #1234 (resolved by #5678) * @user1 @user2 @user3 reviewed pull requests -**Full Changelog**: https://github.com/modelcontextprotocol/csharp-sdk/compare/previous-tag...new-tag +**Full Changelog**: https://github.com/modelcontextprotocol/csharp-sdk/compare/{previous-tag}...v{version} + ``` diff --git a/.github/skills/prepare-release/references/apicompat-apidiff.md b/.github/skills/prepare-release/references/apicompat-apidiff.md index 945df1a0f..78d1d13b3 100644 --- a/.github/skills/prepare-release/references/apicompat-apidiff.md +++ b/.github/skills/prepare-release/references/apicompat-apidiff.md @@ -8,16 +8,16 @@ The SDK uses NuGet's [Package Validation](https://learn.microsoft.com/dotnet/fun ```xml true -1.0.0 +{baseline} ``` +Read the current values rather than assuming them, and check whether any individual project overrides them — a project that opts out of validation still ships, and needs to be reported as unvalidated rather than quietly skipped. + ### Running ApiCompat -1. **Pack the SDK packages** to trigger validation: +1. **Pack the SDK packages** to trigger validation. Enumerate the packable projects under `src/` and pack each one; the set of shipping packages grows over time, so do not work from a remembered list: ```sh - dotnet pack src/ModelContextProtocol.Core/ModelContextProtocol.Core.csproj - dotnet pack src/ModelContextProtocol/ModelContextProtocol.csproj - dotnet pack src/ModelContextProtocol.AspNetCore/ModelContextProtocol.AspNetCore.csproj + dotnet pack src/{project}/{project}.csproj ``` Or pack all at once: ```sh @@ -28,17 +28,96 @@ The SDK uses NuGet's [Package Validation](https://learn.microsoft.com/dotnet/fun 3. **Interpret results:** - **No issues**: The API is backward-compatible with the baseline. This is the expected result for PATCH and MINOR releases. + - **`Unnecessary suppressions found`**: **Read this before concluding anything else.** See [Reading a failing run](#reading-a-failing-run) below — the CP lines that follow it are usually *not* live breaks. - **Compatibility errors**: The API has breaking changes relative to the baseline. These should align with the breaking change audit from Step 3 of the prepare-release skill. - - **Suppressions needed**: If intentional breaking changes are confirmed, add entries to `CompatibilitySuppressions.xml` in the affected project directory. + - **Suppressions needed**: If intentional breaking changes are confirmed, add entries to `CompatibilitySuppressions.xml` in the affected project directory — but only after completing the [baseline-transition suppression audit](#baseline-transition-suppression-audit). + +### Reading a failing run + +`Unnecessary suppressions found` is itself a **hard failure**, not a warning attached to some other +problem. When it appears, the `CP0001` / `CP0002` / `CP0005` lines printed after it are the tool's +**detailed listing of the suppression entries it considers unused**. They are not a list of live API +breaks, even though they are formatted identically and appear under the same error banner. + +Misreading that listing is how a routine release turns into a phantom emergency. In this repo it +produced 312 apparent breaking changes across the Core Tasks API on a release whose only real +change was one additive method — and it did so convincingly, because 312 lines of CP0001 for +missing types reads exactly like a catastrophic regression. + +Before classifying a release as breaking, confirm which of the two you are looking at: + +1. **Regenerate the suppression file** (see the audit below). If the generated output is *empty*, + there are no live breaks and every tracked entry is stale. +2. **Cross-check the direct API diff.** If ApiDiff shows only the additions you expect, the CP lines + are not describing reality. + +Never work around this with `ApiCompatPermitUnnecessarySuppressions`, `NoWarn` for CP diagnostics, +or by disabling baseline validation. Those hide the signal that tells you the suppressions and the +baseline have drifted apart, which is the one thing you need to know. ### Updating the Baseline Version - **MAJOR version bump**: Update `` to the previous release version so that ApiCompat validates against the last stable release of the prior MAJOR version. After the new MAJOR release is published, the baseline stays at the new version for future comparisons. - **MINOR or PATCH version bump**: Keep `` at the last MAJOR release version (e.g., keep `1.0.0` when releasing `1.1.0` or `1.0.1`). +**A baseline that trails `VersionPrefix` is the expected steady state, not a stale value.** Through a MAJOR series the baseline deliberately stays put while `VersionPrefix` advances, so seeing `2.0.0` alongside a published `2.1.0` means the rule is being followed. Do not "fix" the gap — bumping the baseline mid-series triggers the audit below and invites the released API surface to be re-baselined against itself, silently discarding the compatibility guarantee the property exists to enforce. + +**Any change to this property triggers the [baseline-transition suppression audit](#baseline-transition-suppression-audit).** Do not change it and interpret the resulting failures as breaking changes — the failures are expected until the suppressions are reconciled. + +### Baseline-transition suppression audit + +**Whenever `PackageValidationBaselineVersion` changes, run this audit before interpreting any +ApiCompat failure and before adding a single suppression entry.** + +Suppression entries are scoped to the baseline they were generated against. They record "this +difference from *that* baseline is intentional." Move the baseline and the differences change, so +entries written for the old baseline may describe nothing at all — the API they excused is now +present on both sides. The tool reports those orphans as unnecessary, and the build fails. + +For **every shipping project**: + +1. Inventory the tracked suppressions: + ```sh + ls src/*/CompatibilitySuppressions.xml + ``` +2. Regenerate what the *current* baseline actually requires, into a throwaway file so the tracked + one is not overwritten while you are still deciding: + ```sh + dotnet clean src/{Project}/{Project}.csproj -c Release + dotnet pack src/{Project}/{Project}.csproj -c Release \ + /p:ApiCompatGenerateSuppressionFile=true \ + /p:ApiCompatSuppressionOutputFile={unique-temp-path} + ``` + Use the **final candidate version and the final baseline** — regenerating against a version you + are about to change invalidates the result. +3. Compare the generated entries against the tracked file, by count and by content. + +| Generated | Tracked | Meaning | Action | +|---|---|---|---| +| Empty | Non-empty | Every tracked entry is stale for this baseline | Clear or delete the tracked file | +| Non-empty | Matches | Suppressions are current | Leave them alone | +| Non-empty | Differs | Some entries stale, some breaks genuinely need suppressing | Reconcile entry by entry, and confirm each remaining break with the user | + +4. After clearing stale entries, rerun the plain CI-equivalent pack with no generation flags, and + require it to pass on its own: + ```sh + dotnet clean -c Release + dotnet pack -c Release + ``` + +Reverting the baseline is the other valid resolution, and sometimes the better one — it keeps the +release diff minimal. Choose deliberately between "advance the baseline and clear the stale +suppressions" and "keep the existing baseline", rather than letting the choice be made by whichever +one silences the error first. Either way, the baseline is determined by what shipped, never selected +to make validation pass. + ### Compatibility Suppressions -When intentional breaking changes are confirmed, create or update `CompatibilitySuppressions.xml` in the affected project directory. The repo already uses this pattern — see `src/ModelContextProtocol.Core/CompatibilitySuppressions.xml` for examples. +When intentional breaking changes are confirmed, create or update `CompatibilitySuppressions.xml` in the affected project directory — the conventional location, which is auto-discovered. + +**A suppression file has three valid outcomes, not one.** Entries get *added* when a new intentional break needs suppressing, *retained* when they still describe a real break against the current baseline, and *cleared* when the baseline moved and they no longer describe anything. Treating the file as append-only is what turned 312 obsolete entries into a release-blocking failure that read as a mass breaking change. Preservation is the default only while the baseline holds still; once it moves, the [audit](#baseline-transition-suppression-audit) decides what stays, and removing entries it proves stale is the fix rather than a regression. + +Do not use a tracked file as a template for what entries should look like — it may legitimately be empty, and its contents describe whatever baseline it was generated against, not yours. Generate entries instead. ```xml @@ -53,7 +132,28 @@ When intentional breaking changes are confirmed, create or update `Compatibility ``` -The exact suppression entries are generated by the pack command when it reports errors — copy the suggested suppression XML from the build output. Remember that suppressions are needed **per target framework** (net10.0, net9.0, net8.0, netstandard2.0). +The exact suppression entries are generated by the pack command when it reports errors — copy the suggested suppression XML from the build output, or generate the file directly with `/p:ApiCompatGenerateSuppressionFile=true`. Remember that suppressions are needed **per target framework** (net10.0, net9.0, net8.0, netstandard2.0). + +#### Wiring the suppression file + +A `CompatibilitySuppressions.xml` sitting in the project directory is **auto-discovered**. That is +the convention this repo uses, and it needs no wiring at all. Do not add MSBuild properties or items +to point at a file that is already found by convention — duplicate or incorrect wiring is easy to +add while chasing a failure and hard to spot afterward, and it ships in the release commit. + +If you do need an explicit path: + +| Name | Kind | Use | +|---|---|---| +| `CompatibilitySuppressionFilePath` | **Property** | The supported way to point at a suppression file explicitly | +| `ApiCompatSuppressionFile` | **Item** | Not a property. Setting it via `/p:` does nothing | +| `ApiCompatSuppressionOutputFile` | **Property** | Where `ApiCompatGenerateSuppressionFile=true` writes its output | + +Retaining an empty suppressions file is fine when you want to keep the file in place after clearing +stale entries. It must still be **valid XML** — an empty `` root, not a zero-byte +file — and it must preserve the repository's byte conventions for these files, including the +UTF-8 BOM and the final newline. A file that differs only in BOM or trailing newline produces a +confusing diff and can trip tooling that round-trips it. ### Common Diagnostic IDs @@ -191,14 +291,37 @@ _or_ [Diff or table of changes] ``` -### In the User Summary (Step 11) +### In the User Summary (Step 12) -Present a condensed version for the user review: +Present a condensed version for the user review. **Report every shipping package, and do not state +that ApiCompat passed without these four facts** — "passed" is not meaningful without knowing what +it was validated against and whether stale suppressions were masking or manufacturing the result: -- **ApiCompat**: pass/fail with count of issues and suppressions per package -- **ApiDiff**: count of additions, removals, and changes per package +| Package | Baseline | Generated entries | Retained / removed | Plain pack | +|---|---|---|---|---| +| {package} | {baseline} | 0 | 0 retained / 312 removed | ✅ | +| {package} | {baseline} | 0 | 0 / 0 | ✅ | + +Enumerate the packable projects under `src/` rather than working from a remembered list; the set +grows. A package that does not participate in validation still gets a row, reporting why — a first +release has no baseline to compare against, and that is a fact worth stating rather than an absence +worth hiding. + +- **Baseline** — the `PackageValidationBaselineVersion` actually used, and whether it changed during + this release +- **Generated entries** — count from `ApiCompatGenerateSuppressionFile=true` at the final version + and baseline +- **Retained / removed** — tracked suppressions kept versus cleared as stale +- **Plain pack** — result of the CI-equivalent `dotnet clean -c Release; dotnet pack -c Release` + with no generation flags, which is the run CI will reproduce + +Then the summary lines: ``` -API Compatibility: ✅ All 3 packages pass (2 existing suppressions in Core) +API Compatibility: ✅ All {n} packages pass against v{baseline} ({n} stale suppressions removed from {package}) API Diff: +12 additions, -2 removals, ~3 changes across all packages ``` + +If the baseline changed, or any suppression file was modified, say so explicitly and explain why. +A silent baseline or suppression edit is the kind of change that passes local validation and then +fails CI. diff --git a/.github/skills/prepare-release/references/categorization.md b/.github/skills/prepare-release/references/categorization.md index 844566759..55d2570b1 100644 --- a/.github/skills/prepare-release/references/categorization.md +++ b/.github/skills/prepare-release/references/categorization.md @@ -11,14 +11,30 @@ Feature work, bug fixes, API improvements, performance enhancements, and any oth - Changes that span code + docs (categorize based on the primary intent) ### Documentation Updates -PRs whose **sole purpose** is documentation. Examples: +PRs whose **sole purpose** is documentation, guidance, or examples. Examples: - Fixing typos in docs - Adding or improving XML doc comments (when not part of a functional change) - Updating conceptual documentation (e.g., files in `docs/`) - README updates - Adding CONTRIBUTING.md or similar guides +- **Adding or improving samples** under `samples/`, including new executable sample projects +- Clarifying how consumers should use existing behavior, even when the PR touches tests to + demonstrate or lock in that behavior -**Important**: A PR that changes code AND updates docs should go in "What's Changed" — only pure documentation PRs belong here. However, documentation PRs should still be studied during the breaking change audit, as they may document changes that were not properly flagged as breaking. +**The test that matters is whether the shipped packages changed**, not whether the PR contains +code. A PR that adds a whole new sample application is still a documentation update: nothing in +`src/` shipped differently because of it. Ask "would a consumer upgrading the NuGet package +observe any difference?" If no, it belongs here. + +**Important**: A PR that changes shipped product code under `src/` AND updates docs should go in +"What's Changed" — only PRs that leave the shipped surface untouched belong here. However, +documentation PRs should still be studied during the breaking change audit, as they may document +changes that were not properly flagged as breaking. + +Categorize conservatively: when a PR could plausibly land in either "What's Changed" or +"Documentation Updates", prefer "Documentation Updates" and surface the call to the user at the +categorization review. Overstating a docs PR as product work inflates the apparent scope of a +release, and it is the error users notice and correct. ### Repository Infrastructure Updates PRs that maintain the development environment but don't affect the shipped product or test coverage. Examples: @@ -114,3 +130,6 @@ Sort entries within each section by **merge date** (chronological order, oldest * @user submitted issue #1234 (resolved by #5678) * @user1 @user2 @user3 reviewed pull requests ``` + +Do not acknowledge maintainers as issue reporters or new contributors; see Step 10 item 7. They +belong only in the reviewers bullet. diff --git a/.github/skills/prepare-release/references/readme-content.md b/.github/skills/prepare-release/references/readme-content.md new file mode 100644 index 000000000..e7fa16aed --- /dev/null +++ b/.github/skills/prepare-release/references/readme-content.md @@ -0,0 +1,94 @@ +# README Content Checklist + +This reference describes what to review and update in the shared embedded NuGet README +(`src/PACKAGE.md`) and the root repository README (`README.md`) as part of every release. + +## The Shared Embedded README + +All SDK packages embed the **same** README file: `src/PACKAGE.md`. + +Each project packs it identically: + +```xml + +README.md +``` + +Updating `src/PACKAGE.md` updates every package's nuget.org README at once. +There are no per-package README files; `src/ModelContextProtocol.Core/README.md` and +similar paths do not exist. + +## Checklist + +### 1. Package-list closure + +Every shipping SDK package must be listed in the packages section of `src/PACKAGE.md`, +including packages introduced after the initial SDK launch and including the package +being viewed in its own embedded README on nuget.org. + +Current packages to list: +- `ModelContextProtocol.Core` +- `ModelContextProtocol` +- `ModelContextProtocol.AspNetCore` +- `ModelContextProtocol.Extensions.Apps` + +Avoid counting phrases such as "three main packages" -- they become stale when packages +are added. Use a non-counting closure such as "The SDK packages are:" instead. + +When a new package is introduced, add it to the list in both `src/PACKAGE.md` and the +root `README.md` (see section below). + +### 2. Badge strategy + +Each package entry carries a nuget.org version badge. The correct badge endpoint depends +on the release type: + +| Release type | Badge endpoint | Example | +|---|---|---| +| Prerelease series (e.g., `2.0.0-preview.*`) | `nuget/vpre/{package}` | `https://img.shields.io/nuget/vpre/ModelContextProtocol.svg` | +| Stable release | `nuget/v/{package}` | `https://img.shields.io/nuget/v/ModelContextProtocol.svg` | + +`nuget/v` renders only the latest stable version and shows nothing (or a placeholder) +during a prerelease-only series. `nuget/vpre` renders the latest version including +prereleases. Switch all package badges together when the release type changes. + +Verify every badge in `src/PACKAGE.md` uses the correct endpoint for this release. + +### 3. Release-notes link + +`src/PACKAGE.md` must contain one statement linking to the release notes for the +current version: + +```markdown +See the [release notes](https://github.com/modelcontextprotocol/csharp-sdk/releases/tag/v{version}) +for what's new in this version. +``` + +Replace `{version}` with the exact version being released, including any prerelease +suffix (e.g., `2.0.0-preview.2`). + +At prepare time the tag does not yet exist; the link is forward-referencing. The link +resolves once the GitHub release is published during the publish-release step. + +Update this link for every release -- it must point to the tag being created, not a +prior release. + +### 4. Root README.md sync + +The root `README.md` (the GitHub repo readme, NOT packed into packages) has its own +package-list section. Keep it aligned with `src/PACKAGE.md`: +- Same set of packages listed +- Same non-counting closure phrasing +- Badge strategy in `README.md` may also be updated for consistency, but the root + README is visible on GitHub (not nuget.org) so the badge choice is less critical + +## Salient content to review + +Beyond the structural checks above, read the current `src/PACKAGE.md` for any content +that has become stale due to changes in this release: + +- Package descriptions (are they still accurate?) +- Getting-started links (do they resolve and describe the current API?) +- Code samples, if any (do they compile against the current SDK? see + [readme-snippets.md](readme-snippets.md)) +- Any version-specific notes from a prior release that should be removed or updated diff --git a/.github/skills/prepare-release/references/readme-snippets.md b/.github/skills/prepare-release/references/readme-snippets.md index 7d2cd4563..a91efeeff 100644 --- a/.github/skills/prepare-release/references/readme-snippets.md +++ b/.github/skills/prepare-release/references/readme-snippets.md @@ -4,19 +4,21 @@ This reference describes how to validate that C# code samples in README files co ## Which READMEs to Validate -Validate code samples from the **package README** files — these are shipped with NuGet packages and are the primary documentation users see: +Validate code samples from the **package README** and the root repository README: -| README | Package | -|--------|---------| -| `README.md` (root) | ModelContextProtocol | -| `src/ModelContextProtocol.Core/README.md` | ModelContextProtocol.Core | -| `src/ModelContextProtocol.AspNetCore/README.md` | ModelContextProtocol.AspNetCore | +| README | Notes | +|--------|-------| +| `src/PACKAGE.md` | The single shared embedded README packed into every SDK package. This is the primary documentation users see on nuget.org. | +| `README.md` (root) | The GitHub repository readme. Not packed into packages, but visible to developers browsing the repo. | -Sample README files (`samples/*/README.md`) are excluded — the samples themselves are buildable projects and are validated by CI. +All SDK packages embed `src/PACKAGE.md` via their `.csproj` files. There are no per-package +README files; paths such as `src/ModelContextProtocol.Core/README.md` do not exist. + +Sample README files (`samples/*/README.md`) are excluded -- the samples themselves are buildable projects and are validated by CI. ## What to Extract -Extract only fenced code blocks tagged as `csharp` (` ```csharp `). Skip blocks tagged as plain ` ``` ` (shell commands, install instructions) or any other language. +Extract only fenced code blocks tagged as `csharp` (` ```csharp `) from `src/PACKAGE.md` and `README.md`. Skip blocks tagged as plain ` ``` ` (shell commands, install instructions) or any other language. ### Handling Incomplete Snippets diff --git a/.github/skills/publish-release/SKILL.md b/.github/skills/publish-release/SKILL.md index fce598c4d..be4d19b74 100644 --- a/.github/skills/publish-release/SKILL.md +++ b/.github/skills/publish-release/SKILL.md @@ -8,17 +8,32 @@ compatibility: Requires gh CLI with repo access and GitHub API access for PR det Create a GitHub release for the `modelcontextprotocol/csharp-sdk` repository after a **prepare-release** PR has been merged. This skill refreshes the release notes to include any PRs merged between the preparation branch point and the merge, warns about changes that affect the version or breaking change assessment, and creates a **draft** GitHub release. +Use the shared [release branch reference](../shared-resources/release-branches.md) for branch roles, previous-release lookup rules, and release work-branch naming. + > **Safety: This skill only creates and updates draft releases. It must never publish a release.** If the user asks to publish, decline and instruct them to publish manually through the GitHub UI. ## Process Work through each step sequentially. Present findings at each step and get user confirmation before proceeding. +### Step 0: Sync With Upstream + +This skill reads the merged release PR, the commit range since the previous release, and the +previous release tag. All three come from local refs that may be stale — most importantly, the +merge commit for the release PR will not exist locally until you fetch. + +1. Identify the remote pointing at `modelcontextprotocol/csharp-sdk` (`git remote -v`) — do not + assume it is `origin`. +2. `git fetch {upstream} --prune --prune-tags --tags` +3. Confirm the merged release PR's merge commit resolves locally. + +Report anything the fetch changed before continuing. + ### Step 1: Identify the Prepare-Release PR The user may provide: - **A PR number or URL** — use directly -- **A version number** (e.g., `1.1.0`) — search for a merged PR titled `Release v{version}` +- **A version number** (e.g., `1.1.0`, `2.0.0-preview.1`) — search for a merged PR titled `Release v{version}`. Prerelease versions are used verbatim, for example `Release v2.0.0-preview.1` - **No context** — list recently merged PRs with `Release v` in the title and ask the user to select Verify the PR is merged. Extract: @@ -28,13 +43,13 @@ Verify the PR is merged. Extract: ### Step 2: Determine Version and Commit Range -1. Read `src/Directory.Build.props` at the merge commit to confirm ``. The tag is `v{VersionPrefix}`. -2. Determine the previous release tag from `gh release list` (most recent **published** release — exclude drafts with `--exclude-drafts`). +1. Read `src/Directory.Build.props` at the merge commit to confirm `` and ``. The tag is `v{VersionPrefix}` plus `-{VersionSuffix}` when the suffix is present; for example, `2.0.0` + `preview.1` → `v2.0.0-preview.1`. +2. Determine the previous release tag from `gh release list` — the **highest semver** among published releases that are ancestors of the merge commit (exclude drafts with `--exclude-drafts`). Do not order by publication date. When the merge commit is on a `release/{MAJOR}.x` branch, restrict candidates to tags matching `v{MAJOR}.*`; on `main`, there is no MAJOR filter. See [release-branches.md](../shared-resources/release-branches.md#previous-release-tag-lookup). 3. Identify the full commit range: previous release tag → merge commit. ### Step 3: Check for Additional PRs -Compare the PRs included in the original prepare-release PR description with the full set of PRs now merged in the commit range. Use the [SemVer assessment guide](../bump-version/references/semver-assessment.md) (owned by the **bump-version** skill) to evaluate the impact of any new PRs against the version that was committed during preparation. +Compare the PRs included in the original prepare-release PR description with the full set of PRs now merged in the commit range. Use the [SemVer assessment guide](../bump-version/references/semver-assessment.md) (owned by the **bump-version** skill) to evaluate the impact of any new PRs against the version that was committed during preparation, including its prerelease and branch-context computation rules. This is not a policy change; only the version computation and previous-release lookup change. 1. Extract the PR list from the prepare-release PR description (all `#NNN` references in release notes sections). 2. Get the full set of PRs merged between the previous release tag and the merge commit. @@ -65,16 +80,45 @@ Re-categorize all PRs in the commit range (including any new ones from Step 3). 1. **Re-run the breaking change audit** using the **breaking-changes** skill if new PRs were found that may introduce breaks. Otherwise, carry forward the results from the prepare-release PR. 2. **Re-categorize** all PRs into sections (What's Changed, Documentation, Tests, Infrastructure). 3. **Re-attribute** co-authors for any new PRs by harvesting `Co-authored-by` trailers from all commits in each PR. -4. **Update acknowledgements** to include contributors from new PRs. +4. **Update acknowledgements** to include contributors from new PRs, excluding maintainers as issue reporters (see prepare-release Step 10 item 7). +5. **Carry forward the prepare-release categorization decisions.** If the user recategorized a PR or removed an acknowledgement during preparation, honor that. Re-deriving categories from scratch will silently reintroduce the exact corrections they already made. +6. **Review with the user** using the categorization table and acknowledgements roster from prepare-release Step 10b — at minimum for PRs new since preparation, and for any entry whose section you changed. Do not fold this into the Step 9 draft-creation gate. + +### Step 5: Review README and Validate Code Samples + +Re-run the README content checklist from [../prepare-release/references/readme-content.md](../prepare-release/references/readme-content.md) and validate code samples against the current SDK at the merge commit. Produce final suggestions before the release is created. -### Step 5: Validate README Code Samples +1. **Content checklist** -- Open `src/PACKAGE.md` and verify: + - **Package-list closure**: every shipping SDK package is listed. If a new package was introduced after prepare-release ran, it may be missing. + - **Badge strategy**: all badges use `nuget/vpre` for a prerelease or `nuget/v` for a stable release. Verify the badge style is correct for this release type. + - **Release-notes link**: the link points to `https://github.com/modelcontextprotocol/csharp-sdk/releases/tag/v{version}` for the tag being created. The tag is about to exist -- verify the URL is correct. + - **Root README.md sync**: confirm the root `README.md` package list is aligned. +2. **Snippet validation** -- Extract `csharp`-fenced code blocks from `src/PACKAGE.md` and `README.md`, build the temporary test project, and report results. Follow [../prepare-release/references/readme-snippets.md](../prepare-release/references/readme-snippets.md) for the full procedure. +3. **Delete** the temporary project after validation. -Verify that all C# code samples in the package README files compile against the current SDK at the merge commit. Follow the [README validation guide](../prepare-release/references/readme-snippets.md) for the full procedure. +If issues are found, present them to the user with proposed fixes. -1. Extract `csharp`-fenced code blocks from `README.md` and `src/PACKAGE.md` -2. Create a temporary test project at `tests/ReadmeSnippetValidation/` -3. Build and report results -4. Delete the temporary project +**Applying them is not a local commit.** The release PR is already merged, so its branch is gone; +fixes belong on the base branch this release ships from (`main` or `release/{MAJOR}.x`), which is +protected. Open a small PR for them, let CI run, and merge it — do not push to the base branch +directly, and do not amend or re-tag anything already reviewed. + +Then **re-target the draft release**, which is pinned to the previously approved merge commit and +therefore does not contain the fix: + +```sh +gh release edit v{version} --target {new-merge-commit-sha} +``` + +Regenerate the release notes afterward so the commit range covers the new PR, and re-run the Step 6 +section review for anything that changed. If the user prefers not to take the fix in this release, +that is a valid choice — leave the draft pinned where it is and note the deferred item, rather than +carrying a fix that the tag will not include. + +**Edge Cases:** +- **Stale package closure** -- A package introduced between prepare-release and now may not be listed. Add it to `src/PACKAGE.md` and `README.md`. +- **Wrong badge style for the release type** -- Switch all badges together from `nuget/vpre` to `nuget/v` (or vice versa) if the prepare-release step used the wrong style. +- **Missing or incorrect release-notes link** -- Correct the link to target the exact tag being created, including any prerelease suffix. ### Step 6: Review Sections @@ -90,7 +134,7 @@ Highlight any changes from the prepare-release draft (new entries, reordered ent ### Step 7: Preamble -Every release **must** have a preamble — a short paragraph summarizing the release theme that appears before the first `##` heading. The preamble is not optional. The preamble may mention the presence of breaking changes as part of the theme summary, but the versioning documentation link belongs under the Breaking Changes heading (see template), not in the preamble. +Every release **must** have a preamble — a short paragraph summarizing the release theme that appears before the first `##` heading. The preamble is not optional. The preamble may mention the presence of breaking changes as part of the theme summary, but the versioning documentation link belongs under the Breaking Changes heading (see template), not in the preamble. That link must use the `v{MAJOR}` slug for the version being released. Extract the draft preamble from the prepare-release PR description and present it alongside a freshly drafted alternative (accounting for any new PRs). @@ -107,15 +151,69 @@ Follow [references/formatting.md](references/formatting.md) when composing and u ### Step 9: Create Draft Release Display release metadata for user review: -- **Title / Tag**: the confirmed version (e.g. `v1.1.0`) -- **Target**: merge commit SHA, its message, and the prepare-release PR link +- **Title / Tag**: the confirmed tag, including any prerelease suffix (e.g. `v1.3.1`, `v2.0.0-preview.1`) +- **Target**: merge commit SHA, its message, the merge commit's branch (the prepare-release PR base), and the prepare-release PR link After confirmation: -- Create with `gh release create --draft` (always `--draft`) +- Create with `gh release create --draft {tag} --target {merge-commit-sha}` (always `--draft`), using the prerelease tag verbatim when present +- **Target the full commit SHA, never a branch name.** A draft sits unpublished until a human + reviews and publishes it, which can be hours. `--target` is resolved when the tag is created -- + at publish time, not now -- so a branch name silently re-resolves to whatever landed on that + branch in the meantime. The tag would then be cut at a commit nobody reviewed, and the release + notes would describe a different commit than the one shipped. The SHA you displayed above is the + commit the user approved; pass that exact SHA. - **Never publish.** If the user asks to publish, decline and instruct them to publish manually. +Pinning the SHA costs nothing, because a draft release does not create the git tag. GitHub stores +the target and creates the tag only when the release is published, so the tag remains uncreated and +the draft fully editable while it waits. + +That is also what makes a late-arriving commit easy to absorb. If the user decides to include work +that merged after the draft was created, do not delete and recreate the release: repoint it with +`gh release edit {tag} --target {new-commit-sha}`, then regenerate the release notes for the new +range and present them for approval again. Never move the target without revising the notes to +match -- a target change silently alters what shipped. + +Then hand off to the user with the publishing checklist: + +> The draft release is ready at {release URL}. Before publishing: +> +> 1. Review the release notes line by line — this is the last review before they are public. +> 2. Check **Set as a pre-release** if this is a prerelease. +> 3. Once you have signed off on the notes, **remove the AI-generated disclosure note** from the +> bottom of the body. It is there because the draft was AI-drafted; after your thorough review +> and sign-off, the published notes stand as your reviewed work. +> 4. Click **Publish release**. + +The disclosure is removed by the **user**, as part of their sign-off — never remove it yourself, and +never remove it from a pull request description, an issue, or a comment. If the user asks you to +edit the draft body after they have removed it, do not reintroduce it. + When the user requests revisions after the initial creation, always rewrite the complete body as a file — never perform in-place string replacements. See [references/formatting.md](references/formatting.md). +### Step 10: Watch for Publication + +Do not end the skill by asking the user to report back when they have published. Poll the release +until it is no longer a draft: + +```sh +gh release view v{version} --json isDraft,publishedAt,tagName,isPrerelease +``` + +Poll at a modest interval — this gate is human-paced and may span hours or a session boundary. Say +that you are watching rather than going silent. + +When `isDraft` becomes `false`: + +1. Record the publication time from `publishedAt`, not from when the poll noticed. +2. Confirm the tag that was actually created and whether the release was marked as a prerelease. + Both were the user's to set and cannot be inferred. +3. **Hand off to the verify-release skill immediately.** Publishing starts the Release and Publish + Docs workflows in parallel at that moment; verification that begins late misses them mid-flight. + +If the user reports publishing but the API still shows a draft, trust the API and say so — an +unsaved draft looks identical to a published release from the browser. + ## Edge Cases - **No new PRs since preparation**: proceed normally — the prepare-release notes are used as the foundation with no warnings @@ -127,18 +225,23 @@ When the user requests revisions after the initial creation, always rewrite the - **PR spans categories**: categorize by primary intent - **Copilot timeline missing**: fall back to `Co-authored-by` trailers to determine whether `@Copilot` should be a co-author; if still unclear, use `@Copilot` as primary author - **No breaking changes**: omit the Breaking Changes section entirely +- **Versioning link carried over from the prepare-release draft**: the draft may contain an unslugged or wrong-MAJOR versioning link. Correct it to the `v{MAJOR}` slug of the version being released before the draft release is created. +- **Versioning link for a brand-new MAJOR**: the `/v{MAJOR}/versioning.html` path is created by the Publish Docs workflow when the release is published. It is expected to 404 until then; use the slugged form regardless. - **Single breaking change**: use the same numbered format as multiple +- **Draft edited but not published**: the user is still reviewing, and may be removing the AI disclosure. Take no action and do not reintroduce anything they removed +- **Draft disappears without a published release**: it may have been deleted, or published under a different tag. Check for a published release before assuming it was abandoned, then ask +- **Published tag differs from the prepared version**: stop and confirm with the user before verifying. Verifying the wrong version is worse than not verifying ## Release Notes Template -Omit empty sections. The preamble is **always required** — it is not inside a section heading. +Omit empty sections. The preamble is **always required** — it is not inside a section heading. Tags may include prerelease suffixes, such as `v2.0.0-preview.1`, and Full Changelog compare links should use the exact tag. The versioning link uses the `v{MAJOR}` slug for the version being released — see [release-branches.md](../shared-resources/release-branches.md#versioning-documentation-links). ```markdown [Preamble — REQUIRED. Summarize the release theme.] ## Breaking Changes -Refer to the [C# SDK Versioning](https://csharp.sdk.modelcontextprotocol.io/versioning.html) documentation for details on versioning and breaking change policies. +Refer to the [C# SDK Versioning](https://csharp.sdk.modelcontextprotocol.io/v{MAJOR}/versioning.html) documentation for details on versioning and breaking change policies. 1. **Description #PR** * Detail of the break @@ -166,5 +269,6 @@ Refer to the [C# SDK Versioning](https://csharp.sdk.modelcontextprotocol.io/vers * @user submitted issue #1234 (resolved by #5678) * @user1 @user2 @user3 reviewed pull requests -**Full Changelog**: https://github.com/modelcontextprotocol/csharp-sdk/compare/previous-tag...new-tag +**Full Changelog**: https://github.com/modelcontextprotocol/csharp-sdk/compare/{previous-tag}...v{version} + ``` diff --git a/.github/skills/publish-release/references/formatting.md b/.github/skills/publish-release/references/formatting.md index 467dbb3f2..888f3c5f4 100644 --- a/.github/skills/publish-release/references/formatting.md +++ b/.github/skills/publish-release/references/formatting.md @@ -27,7 +27,7 @@ When the user requests changes to existing release notes: 1. Fetch the current release body and save it to a local file 2. **Breaking change audit**: Run the full breaking-changes skill audit on the commit range, just as for new release notes — this includes examining PRs, reconciling labels, offering to comment on PRs, and getting user confirmation. Also extract any breaking changes already documented in the existing release body; these must be preserved and reconciled with the audit results. -3. **Preamble check**: Verify the release has a preamble (text before the first `##` heading). If missing, compose one. The versioning documentation link belongs under the `## Breaking Changes` heading, not in the preamble. +3. **Preamble check**: Verify the release has a preamble (text before the first `##` heading). If missing, compose one. The versioning documentation link belongs under the `## Breaking Changes` heading, not in the preamble, and must use the `v{MAJOR}` slug for the released version — see [release-branches.md](../../shared-resources/release-branches.md#versioning-documentation-links). 4. Write the **entire** corrected body to a separate local file (ensuring proper line breaks between all sections, entries, and paragraphs) 5. Run `git diff --no-index` between the original and updated files and **always** present the raw diff output directly in the response as a fenced code block with `diff` syntax highlighting. Do not summarize or paraphrase the diff — always show the complete diff to the user. Require explicit confirmation before uploading. For published releases (not drafts), also offer to save the original body to a permanent local file, noting that GitHub does not retain prior versions of release notes. 6. Upload the complete file using `gh release edit --notes-file ` @@ -47,8 +47,25 @@ After every release body update: - [ ] Preamble exists before the first `##` heading - [ ] If `## Breaking Changes` section exists, it begins with the versioning docs link paragraph before the numbered list +- [ ] The versioning docs link uses the `v{MAJOR}` slug for the released version (e.g. `/v2/versioning.html`), never the unslugged `/versioning.html` - [ ] Line count matches expected structure (~80+ lines for a typical release) - [ ] Section headings (`## Breaking Changes`, `## What's Changed`, etc.) each appear on their own line - [ ] Bullet entries are each on their own line - [ ] No stray characters at the start of the body - [ ] Preview the release on GitHub to confirm rendering + +## AI Disclosure + +A draft release body created by an agent carries a concise AI-generated disclosure at the bottom: + +```markdown +> [!NOTE] +> These release notes were drafted with GitHub Copilot and reviewed before publishing. +``` + +Keep it on the draft. Removing it is the **user's** decision, made as part of their final sign-off +once they have reviewed the notes line by line and are satisfied the content is theirs. Never remove +it on your own initiative, and never reintroduce it after the user has removed it. + +This exception applies only to release notes, which get a dedicated human review before publishing. +Disclosures on pull request descriptions, issues, and comments always remain. diff --git a/.github/skills/run-conformance-from-branch/SKILL.md b/.github/skills/run-conformance-from-branch/SKILL.md new file mode 100644 index 000000000..ee2de1986 --- /dev/null +++ b/.github/skills/run-conformance-from-branch/SKILL.md @@ -0,0 +1,76 @@ +--- +name: run-conformance-from-branch +description: Run MCP conformance tests in the C# SDK against a conformance branch (including forks) instead of the published npm version, then restore pinned dependencies. +compatibility: Requires npm, node, and dotnet SDK. Uses the csharp-sdk repo package.json/package-lock.json and tests/ModelContextProtocol.AspNetCore.Tests. +--- + +# Run Conformance From Branch + +Run C# SDK conformance tests against an unpublished `modelcontextprotocol/conformance` branch (including branches in forks). + +## Use Cases + +- Validate a conformance PR before it is published to npm +- Validate C# SDK behavior against a fork with custom scenario changes +- Reproduce failures caused by conformance changes + +## Safety / Repo Hygiene + +1. Start from a clean git state. +2. Commit or stash local changes first. +3. Restore pinned dependencies when done (`npm ci`). + +## Inputs + +- **Source type**: `upstream-branch` or `fork-branch` +- **Source locator**: + - Upstream branch: `modelcontextprotocol/conformance#` + - Fork branch: `/conformance#` +- **Scenario** (optional): e.g. `auth/scope-step-up` + +## Workflows + +### A) Install directly from GitHub branch (upstream or fork) + +From `csharp-sdk` root: + +```bash +npm install --no-save @modelcontextprotocol/conformance@github:/conformance# +``` + +Examples: + +```bash +npm install --no-save @modelcontextprotocol/conformance@github:modelcontextprotocol/conformance#main +npm install --no-save @modelcontextprotocol/conformance@github:myuser/conformance#sep-2350-check +``` + +## Run Tests + +### Run client conformance tests with dotnet test filter: + +```bash +dotnet test tests/ModelContextProtocol.AspNetCore.Tests/ModelContextProtocol.AspNetCore.Tests.csproj -f net10.0 --filter "FullyQualifiedName~ClientConformanceTests" +``` + +### Run server conformance tests with dotnet test filter: + +```bash +dotnet test tests/ModelContextProtocol.AspNetCore.Tests/ModelContextProtocol.AspNetCore.Tests.csproj -f net10.0 --filter "FullyQualifiedName~ServerConformanceTests" +``` + +## Reporting + +Always report: + +1. Installed conformance source (`npm ls @modelcontextprotocol/conformance --depth=0`) +2. Scenario results (pass/fail/warnings) +3. Any new check IDs observed (for traceability) + +## Cleanup / Restore + +Return repo to pinned dependency state: + +```bash +npm ci +``` diff --git a/.github/skills/shared-resources/release-branches.md b/.github/skills/shared-resources/release-branches.md new file mode 100644 index 000000000..298776b6a --- /dev/null +++ b/.github/skills/shared-resources/release-branches.md @@ -0,0 +1,89 @@ +# Release Branches + +Shared reference for release skills. Describes the branch roles used by the release workflow and the rules each skill follows for selecting a branch and looking up the previous release. + +## Branch roles + +| Branch | Purpose | CI behavior | +| ------------------- | ----------------------------------------------- | -------------------------------------- | +| `main` | Next-MAJOR preview/development line | Nightly `cron` build → GitHub Packages | +| `release/{MAJOR}.x` | Long-lived servicing branch for a shipped MAJOR | Every push → GitHub Packages | +| `release-{version}` | Short-lived release preparation branch | Built by PR CI; no package publishing | + +Official NuGet.org publishes happen only when a GitHub Release is created from a branch's tag. + +## Selecting a source/base branch (`prepare-release` Step 1) + +1. List candidate branches via: + `gh api repos/{owner}/{repo}/branches --paginate --jq '[.[] | select(.name == "main" or (.name | startswith("release/"))) | .name]'` +2. Present the list to the user. Default selection: `main`. +3. The selected branch drives: + - Previous-release lookup (see below). + - The branch on which the candidate version is read from `src/Directory.Build.props`. + - The commit range from which PRs are collected. + - The `--base` of the PR created at the end of the skill. + +## Previous-release tag lookup + +Select the **highest semver** among published releases that are **ancestors of the target commit**, +excluding drafts: + +```sh +gh release list --exclude-drafts --limit 50 +``` + +- On `main`: no MAJOR filter — the highest semver ancestor wins. +- On `release/{MAJOR}.x`: restrict candidates to tags matching `v{MAJOR}.*`. + +**"Highest semver" and "most recent by date" are not the same rule, and the difference is not +hypothetical.** Ship `v2.1.0` from `main`, then a `v2.0.1` servicing patch from `release/2.0.x`, and +the most recently *published* release is `v2.0.1` while the highest semver is `v2.1.0`. Ordering by +date picks a tag that is not on `main` at all, which produces a bogus PR range and makes ApiCompat +report the entire API surface as removed. Order by version, not by publication time. + +The ancestry constraint is what makes this safe across branches, so verify it rather than assuming +the version ordering implied it — a tag can be both the highest semver and unreachable from the +target. `prepare-release` Step 2 performs this check explicitly. + +This is purely a baseline-selection rule. It does **not** change the breaking-change policy. See [the versioning docs](https://csharp.sdk.modelcontextprotocol.io/versioning.html) for the policy. + +## Versioning documentation links + +The documentation site is published per major version under a `v{MAJOR}` slug (`/v1/`, `/v2/`). Any +link to the versioning documentation from **release notes** — both the release-notes link and the +paragraph under the `## Breaking Changes` heading — must point at the slugged instance for the +version being released: + +``` +https://csharp.sdk.modelcontextprotocol.io/v{MAJOR}/versioning.html +``` + +The slug is derived from the **MAJOR component of the version being released**, not from the branch: + +| Version being released | Versioning link | +| ---------------------- | --------------- | +| `1.3.1` | `https://csharp.sdk.modelcontextprotocol.io/v1/versioning.html` | +| `2.0.0-preview.1` | `https://csharp.sdk.modelcontextprotocol.io/v2/versioning.html` | +| `2.0.0` | `https://csharp.sdk.modelcontextprotocol.io/v2/versioning.html` | + +The branch is normally consistent with this — `release/1.x` releases `1.x` versions and `main` +currently releases `2.x` — but the version is what determines the slug. If a release's MAJOR ever +disagrees with its branch's MAJOR, follow the version. + +Prerelease suffixes do not affect the slug: `2.0.0-preview.1` and `2.0.0` both use `/v2/`. + +The unslugged `https://csharp.sdk.modelcontextprotocol.io/versioning.html` redirects to the site's +default version, which tracks the newest release. It is therefore unstable for a published release's +notes — a later MAJOR would silently repoint it. Never use the unslugged form in release notes. + +**First release of a new MAJOR**: the `/v{MAJOR}/` path does not exist until the Publish Docs +workflow runs, which happens when the GitHub release is published. The link is forward-referencing +at prepare and publish time, exactly like the release-notes tag link, and resolves once the release +is published. The **verify-release** skill confirms it. + +Prepare-release work branches are named `release-{version}` (flat, hyphen-separated): +- `release-2.0.0-preview.1` +- `release-1.3.1` +- `release-2.0.0` + +Hyphens in prerelease versions are valid in git branch names. diff --git a/.github/skills/verify-release/SKILL.md b/.github/skills/verify-release/SKILL.md new file mode 100644 index 000000000..1f8a706b2 --- /dev/null +++ b/.github/skills/verify-release/SKILL.md @@ -0,0 +1,190 @@ +--- +name: verify-release +description: Verify a published release of the C# MCP SDK. Monitors the Release and Publish Docs workflows triggered by publishing a GitHub release, confirms the packages are listed on NuGet.org, and confirms the versioned documentation site reflects the release. Use when asked to verify a release, check whether a release published correctly, monitor the release or docs workflow, confirm packages on NuGet, or check whether the docs site updated. +compatibility: Requires gh CLI with repo access for workflow runs and releases, and network access to nuget.org and csharp.sdk.modelcontextprotocol.io. +--- + +# Verify Release + +Verify that a published release of `modelcontextprotocol/csharp-sdk` fully shipped. Publishing a +GitHub release triggers **two workflows in parallel**, and the release is not done until both have +succeeded and both of their outputs are confirmed live. + +| Workflow | File | Trigger | Produces | +|---|---|---|---| +| Release | [`.github/workflows/release.yml`](../../workflows/release.yml) | `release: published` | NuGet packages published to NuGet.org | +| Publish Docs | [`.github/workflows/docs.yml`](../../workflows/docs.yml) | `release: published` | The versioned docs site at | + +Use the shared [release branch reference](../shared-resources/release-branches.md) for branch roles +and release tag conventions. + +> **Safety: This skill is read-only by default.** It inspects workflow runs, releases, and published +> artifacts. The only actions it may take are re-running a failed workflow or dispatching a docs +> refresh, and both require explicit user confirmation. + +## Process + +Work through each step sequentially. Present findings at each step and get user confirmation before +taking any action. + +### Step 1: Identify the Release + +The user may provide: +- **A version or tag** (e.g., `2.0.0-preview.1`, `v1.3.1`) — use directly +- **No context** — list recent releases with `gh release list --limit 10` and ask the user to select + +Confirm the release is **published**, not a draft: + +``` +gh release view {tag} --json tagName,isDraft,isPrerelease,publishedAt,targetCommitish,url +``` + +If the release is still a draft, **stop**. Neither workflow has run — nothing is published, and no +verification is possible. Tell the user the draft must be published in the GitHub UI first, and +that publishing is a deliberate human action this skill will not perform. + +Record the tag, the published timestamp, and the target commitish for the following steps. + +### Step 2: Locate Both Workflow Runs + +Find the runs triggered by publishing this release. A release-event run carries the **tag name in +`headBranch`**, which is an exact identifier — use it rather than correlating on timestamps: + +``` +gh run list --workflow release.yml --event release --branch v{version} --limit 5 --json databaseId,status,conclusion,headBranch,headSha,createdAt,url +gh run list --workflow docs.yml --event release --branch v{version} --limit 5 --json databaseId,status,conclusion,headBranch,headSha,createdAt,url +``` + +**Do not identify runs by "the most recent run" or "created at or after `publishedAt`."** Those +match any release published in the same window, so a concurrent or closely-following release — +including a servicing patch published from another branch minutes later — can be reported as this +release's result, showing a green run for the wrong tag. Confirm `headBranch` equals `v{version}` +on every run before evaluating it. + +Cross-check `headSha` against the release's target commitish recorded in Step 1. A mismatch means +the tag moved between drafting and publishing, and the run validated something other than what was +reviewed — stop and report it rather than evaluating the run. + +If more than one run matches the tag, the workflow was re-run; evaluate the **latest attempt** and +say that earlier attempts existed rather than silently reporting only the newest. + +Present both runs with their status, conclusion, and URL. Watch them **together** — they run +concurrently and either can fail independently. Do not report success for the release until both +are accounted for. + +If a run cannot be found for either workflow, report which one is missing and check whether the +workflow is disabled or whether its `if` repository guard excluded the run (both workflows only run +in the `modelcontextprotocol/csharp-sdk` repository, not in forks). + +### Step 3: Evaluate the Release Workflow + +Report the run's conclusion. If it failed, identify the failing job and step and summarize the +error: + +``` +gh run view {run-id} --log-failed +``` + +A failure here does **not** roll back the release — the GitHub release and its tag remain, and the +workflow is simply re-run once the cause is addressed. Re-running is safe and is usually the right +first move. Recommend it, but **do not re-run without explicit user confirmation**. + +> **Never run `dotnet nuget push` and never handle NuGet API keys.** Package publishing happens only +> through the workflow. + +### Step 4: Evaluate the Publish Docs Workflow + +Report the run's conclusion, accounting for these docs-specific behaviors: + +- **Superseded runs are not failures.** The workflow uses a `pages` concurrency group with + `cancel-in-progress: true`. Every run rediscovers the current releases and rebuilds the whole site + from scratch, so a newer run fully supersedes the one it cancels. Report a cancelled run as + *superseded* and follow the newer run instead. +- **Version discovery reads published releases.** For each major version >= 1, the workflow takes + the most recently published non-draft release tagged `v{MAJOR}.*`. A draft release contributes + nothing. +- **Every major is rebuilt.** Each major's docs are built from that major's latest release tag into + its own path (`/v1/`, `/v2/`). A new MAJOR adds a new path; the site root redirects to the newest + release, prereleases included. +- **Orchestration comes from `main`.** The scripts and picker assets are always checked out from + `main`, while each version's content comes from its release tag. A docs fix that lives only in a + release branch will not affect orchestration. + +If it failed, summarize the failing step. Common causes are a docs build failure in one version's +worktree (`make generate-docs`) or a Pages deployment error. + +### Step 5: Confirm the Published Packages + +Confirm the exact released version is listed for each shipping package on NuGet.org. + +Listing can lag a successful workflow run by several minutes. If the workflow succeeded but the +version is not yet visible, say so explicitly and offer to re-check — **do not report this as a +failure**. Distinguish "published but not yet indexed" from "not published." + +Report each package with its status, and flag any shipping package missing from the release. + +### Step 6: Confirm the Documentation Site + +Confirm reflects this release: + +1. **Version path** — the major-version path for this release (for example `/v2/`) is live and + serving the new content. +2. **Version picker** — the picker offers this release's major version. +3. **Root redirect** — the site root redirects to the expected default version, which is the newest + release by publish date, prereleases included. +4. **Versioning page** — the slugged versioning page for this release, + `https://csharp.sdk.modelcontextprotocol.io/v{MAJOR}/versioning.html`, resolves. Release notes + link to it from the Breaking Changes section, and for the first release of a new MAJOR that path + only comes into existence with this workflow run. Confirm the release notes use the slugged form + and not the unslugged `/versioning.html`, which tracks the site default and can silently repoint + when a later MAJOR ships. + +GitHub Pages caches aggressively, so a short delay after a successful deploy is normal. +Distinguish "deployed but not yet propagated" from "deployed wrong." + +### Step 7: Report + +Summarize the verification as a table covering both workflows and both published outputs, and state +plainly whether the release is fully verified or what remains outstanding. + +| Check | Status | +|---|---| +| Release workflow | ✅ succeeded — {run URL} | +| Publish Docs workflow | ✅ succeeded — {run URL} | +| Packages on NuGet.org | ✅ {version} listed for all N packages | +| Docs site | ✅ `/v2/` live, picker updated, root redirects | + +## Remediation + +Both remediations require explicit user confirmation. + +**Re-run a failed workflow:** + +``` +gh run rerun {run-id} --failed +``` + +**Refresh the docs without a new release** — when documentation content needs correcting after the +release, the docs workflow accepts a manual dispatch that rebuilds one major version's content from +an arbitrary ref, without minting a product release: + +``` +gh workflow run docs.yml --field docs_ref={branch-tag-or-commit} +``` + +The ref's major version, read from `src/Directory.Build.props`, must have a published release; the +workflow fails fast if it does not. This replaces only the matching major's HTML — orchestration +and all other versions are unaffected. + +## Edge Cases + +- **Release is still a draft** — stop; neither workflow has run. The user must publish in the GitHub UI. +- **Docs run cancelled** — expected under the `pages` concurrency group; report as superseded and follow the newer run. +- **Only one workflow ran** — check whether the other is disabled, or whether the repository guard excluded it (forks do not run either workflow). +- **Workflow succeeded but NuGet version not listed** — indexing lag; re-check before reporting a failure. +- **Workflow succeeded but docs not visible** — Pages caching; re-check before reporting a failure. +- **Docs site missing the new major version** — confirm the release is published and non-draft, then confirm the tag matches `v{MAJOR}.*`. +- **Root redirects to an unexpected version** — the default is the newest release *by publish date*, including prereleases. A prerelease published after a stable release becomes the default; this is by design. +- **Release workflow failed after partial publish** — some packages may already be on NuGet.org. NuGet versions cannot be unpublished; re-running skips already-published versions. Report exactly which packages are listed before recommending a re-run. +- **Versioning link is unslugged or points at the wrong MAJOR** — release notes must link to `/v{MAJOR}/versioning.html` for the released version. Report it so the user can correct the body; the unslugged form tracks the site default and will repoint when a later MAJOR ships. +- **Verifying an older release** — the docs workflow only ever reflects each major's *latest* release, so an older release's docs path will have been overwritten by a newer one. Verify packages only and note this. diff --git a/.github/workflows/ci-build-test.yml b/.github/workflows/ci-build-test.yml index dc788d08e..86e48a277 100644 --- a/.github/workflows/ci-build-test.yml +++ b/.github/workflows/ci-build-test.yml @@ -38,21 +38,21 @@ jobs: steps: - name: 📥 Clone the repo - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 with: fetch-depth: 0 # Shallow clones should be disabled for a better relevancy of analysis - name: 🔧 Set up .NET - uses: actions/setup-dotnet@c2fa09f4bde5ebb9d1777cf28262a3eb3db3ced7 # v5.2.0 + uses: actions/setup-dotnet@a98b56852c35b8e3190ac28c8c2271da59106c68 # v6.0.0 with: dotnet-version: | 10.0.x 9.0.x - name: 🔧 Set up Node.js - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0 + uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0 with: - node-version: '20' + node-version: '22' - name: 📦 Install pinned npm dependencies for tests run: npm ci diff --git a/.github/workflows/ci-code-coverage.yml b/.github/workflows/ci-code-coverage.yml index e12d00f68..e328f2b89 100644 --- a/.github/workflows/ci-code-coverage.yml +++ b/.github/workflows/ci-code-coverage.yml @@ -10,9 +10,9 @@ jobs: publish-coverage: runs-on: ubuntu-latest steps: - - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 - name: Setup .NET - uses: actions/setup-dotnet@c2fa09f4bde5ebb9d1777cf28262a3eb3db3ced7 # v5.2.0 + uses: actions/setup-dotnet@a98b56852c35b8e3190ac28c8c2271da59106c68 # v6.0.0 with: dotnet-version: | 10.0.x @@ -24,7 +24,7 @@ jobs: pattern: testresults-* - name: Combine coverage reports - uses: danielpalme/ReportGenerator-GitHub-Action@5.5.5 + uses: danielpalme/ReportGenerator-GitHub-Action@d3ebf1f760f7d8ab92cc44d9bcfee7ad73722a31 # 5.5.11 with: reports: "**/*.cobertura.xml" targetdir: "${{ github.workspace }}/report" diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml index e5e53d60b..bed505df4 100644 --- a/.github/workflows/codeql.yml +++ b/.github/workflows/codeql.yml @@ -2,9 +2,9 @@ name: "CodeQL" on: push: - branches: [ "main", "validation/**" ] + branches: [ "main", "release/**", "validation/**" ] pull_request: - branches: [ "main", "validation/**" ] + branches: [ "main", "release/**", "validation/**" ] schedule: - cron: '23 9 * * 6' @@ -47,7 +47,7 @@ jobs: # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages steps: - name: Checkout repository - uses: actions/checkout@v6 + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 # Add any setup steps before running the `github/codeql-action/init` action. # This includes steps like installing compilers or runtimes (`actions/setup-node` diff --git a/.github/workflows/copilot-setup-steps.yml b/.github/workflows/copilot-setup-steps.yml index 6d0ed95e3..580ac1cfe 100644 --- a/.github/workflows/copilot-setup-steps.yml +++ b/.github/workflows/copilot-setup-steps.yml @@ -11,10 +11,10 @@ jobs: contents: read steps: - - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 - name: Install .NET SDK - uses: actions/setup-dotnet@v5.2.0 + uses: actions/setup-dotnet@a98b56852c35b8e3190ac28c8c2271da59106c68 # v6.0.0 with: global-json-file: global.json diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index eba0c0b2a..1e187ef5f 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -1,9 +1,24 @@ name: Publish Docs +# Publishes the versioned docs site to GitHub Pages. +# +# Discovers the versions to publish from the repository's GitHub releases (the +# latest release, by date, for each major >= 1), builds each release tag into +# its own sub-path (e.g. /v1/ and /v2/) with make generate-docs, injects a +# version-picker widget into each page, adds a root redirect to the default +# version, and deploys the combined site. A manual dispatch can also rebuild +# the matching major-version path from a specified branch, tag, or commit. +# Triggers on release publish and manual dispatch. + on: release: types: [published] workflow_dispatch: + inputs: + docs_ref: + description: Branch, tag, or commit whose docs should refresh its matching major version + required: false + type: string # Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages permissions: @@ -11,11 +26,12 @@ permissions: pages: write id-token: write # Required for actions/deploy-pages -# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued. -# However, do NOT cancel in-progress runs as we want to allow these production deployments to complete. +# Allow only one concurrent deployment. Cancel any in-progress run when a newer one +# starts: every run rediscovers the current releases and rebuilds the whole site from +# scratch, so a newer run fully supersedes the work of the one it cancels. concurrency: group: "pages" - cancel-in-progress: false + cancel-in-progress: true jobs: publish-docs: @@ -26,23 +42,113 @@ jobs: url: ${{ steps.deployment.outputs.page_url }} runs-on: ubuntu-latest steps: - - name: Checkout - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + - name: Checkout docs orchestration + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + # A release event otherwise checks out the released tag. Keep the + # orchestration scripts and picker assets current with main. + ref: main + # Full history + tags so we can add a worktree for each version's release tag. + fetch-depth: 0 - name: .NET Setup - uses: actions/setup-dotnet@c2fa09f4bde5ebb9d1777cf28262a3eb3db3ced7 # v5.2.0 + uses: actions/setup-dotnet@a98b56852c35b8e3190ac28c8c2271da59106c68 # v6.0.0 with: dotnet-version: | 10.0.x 9.0.x - - name: Generate documentation - run: make generate-docs + - name: Discover versions from GitHub releases + shell: bash + env: + GH_TOKEN: ${{ github.token }} + # For every major version >= 1, take the most recently published (by date) + # non-draft release tagged v{major}.*. The vN prefix becomes the URL slug; + # the site root redirects to the newest release, including prereleases. + run: | + set -euo pipefail + gh release list --repo "${{ github.repository }}" --limit 200 \ + --json tagName,isPrerelease,isDraft,publishedAt \ + --jq ' + [ .[] + | select((.isDraft | not) and (.tagName | test("^v[1-9][0-9]*\\."))) + | { slug: (.tagName | match("^v[0-9]+").string), + ref: .tagName, label: .tagName, + prerelease: .isPrerelease, published: .publishedAt } + ] + | group_by(.slug) + | map(max_by(.published)) + | sort_by(.published) | reverse + | { default: .[0].slug, + versions: map({ slug, ref, label, prerelease }) } + ' | tee "$RUNNER_TEMP/docs-versions.json" + + - name: Build all versions + shell: bash + env: + CONTENT_REF: ${{ inputs.docs_ref }} + run: | + set -euo pipefail + ROOT="$PWD" + COMBINED="$ROOT/combined" + rm -rf "$COMBINED" + mkdir -p "$COMBINED" + + # Orchestration (discovered docs-versions.json, scripts, picker assets) + # always comes from THIS branch. Normally each version's HTML is produced + # by its release tag. A manual docs_ref replaces the matching major's + # HTML with content built from that ref, allowing content-only refreshes + # without minting a product release. + git fetch --tags --force origin + CONTENT_REF="${CONTENT_REF:-}" + CONTENT_WORKTREE="" + CONTENT_SLUG="" + if [[ -n "$CONTENT_REF" ]]; then + CONTENT_WORKTREE="$ROOT/../work-content" + git worktree add --force --detach "$CONTENT_WORKTREE" "$CONTENT_REF" + CONTENT_SLUG="$(node "$ROOT/scripts/get-docs-version-slug.mjs" "$CONTENT_WORKTREE/src/Directory.Build.props")" + if ! node "$ROOT/scripts/list-versions.mjs" | cut -f1 | grep -Fxq "$CONTENT_SLUG"; then + echo "::error::The docs ref '$CONTENT_REF' has major '$CONTENT_SLUG', which has no published release." + exit 1 + fi + echo "Refreshing $CONTENT_SLUG docs from $CONTENT_REF" + fi + + while IFS=$'\t' read -r slug ref; do + if [[ "$slug" == "$CONTENT_SLUG" ]]; then + echo "::group::Build $slug (from ref $CONTENT_REF)" + wt="$CONTENT_WORKTREE" + else + echo "::group::Build $slug (from tag $ref)" + wt="$ROOT/../work-$slug" + git worktree add --force --detach "$wt" "refs/tags/$ref" + fi + + make -C "$wt" generate-docs + + mkdir -p "$COMBINED/$slug" + cp -a "$wt/artifacts/_site/." "$COMBINED/$slug/" + node "$ROOT/scripts/inject-version-picker.mjs" "$COMBINED/$slug" "$slug" --base / + + if [[ "$wt" != "$CONTENT_WORKTREE" ]]; then + git worktree remove --force "$wt" + fi + echo "::endgroup::" + done < <(node "$ROOT/scripts/list-versions.mjs") + + if [[ -n "$CONTENT_WORKTREE" ]]; then + git worktree remove --force "$CONTENT_WORKTREE" + fi + + node "$ROOT/scripts/finalize-docs-site.mjs" "$COMBINED" + + echo "Combined site contents:" + ls -la "$COMBINED" - name: Upload Pages artifact uses: actions/upload-pages-artifact@fc324d3547104276b827a68afc52ff2a11cc49c9 # v5.0.0 with: - path: 'artifacts/_site' + path: 'combined' - name: Deploy to GitHub Pages id: deployment diff --git a/.github/workflows/markdown-link-check.yml b/.github/workflows/markdown-link-check.yml index dd907de65..1dbf83b0e 100644 --- a/.github/workflows/markdown-link-check.yml +++ b/.github/workflows/markdown-link-check.yml @@ -16,7 +16,7 @@ jobs: runs-on: ubuntu-latest steps: - name: Checkout - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 - name: Markup Link Checker (mlc) uses: becheran/mlc@7ec24825cefe0c9c8c6bac48430e1f69e3ec356e # v1.2.0 diff --git a/.github/workflows/release.md b/.github/workflows/release.md deleted file mode 100644 index 87005a64a..000000000 --- a/.github/workflows/release.md +++ /dev/null @@ -1,27 +0,0 @@ -# Release Process - -The following process is used when publishing new releases to NuGet.org. - -## 1. Ensure the CI workflow is fully green - -- Some integration tests are flaky and may require re-running -- Once the state of the branch is known to be good, a release can proceed -- **The release workflow _does not_ run tests** — CI must be green before starting - -## 2. Prepare the release - -From a local clone of the repository, use Copilot CLI to invoke the `prepare-release` skill. The skill assesses the semantic version, bumps the version in [`src/Directory.Build.props`](../../src/Directory.Build.props), runs API compatibility checks, reviews documentation, drafts release notes, and creates a pull request with all release artifacts. - -Review the PR, request changes if needed, and merge when ready. - -## 3. Publish the release - -After the prepare-release PR is merged, invoke the `publish-release` skill. The skill checks for any late-arriving PRs that could affect the release, refreshes the release notes, and creates a **draft** GitHub release. - -Review the draft release on GitHub, check 'Set as a pre-release' if appropriate, and click 'Publish release'. - -## 4. Monitor the Release workflow - -- After publishing, a workflow will produce build artifacts and publish the NuGet packages to NuGet.org -- If the job fails, troubleshoot and re-run the workflow as needed -- Verify the package version becomes listed at [nuget.org/packages/ModelContextProtocol](https://www.nuget.org/packages/ModelContextProtocol) diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 2c4842ba0..4c96a86b6 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -1,19 +1,24 @@ # Publish new package versions of ModelContextProtocol # -# Daily and Manual Runs -# - Triggered automatically at 07:00 UTC daily -# - Triggered manually using GitHub Actions workflow_dispatch event -# - Version prefix applied from /src/Directory.Build.props -# - Version suffix set to `ci.{github.run_number}` -# - Package published to GitHub package registry +# Triggers +# - Scheduled (07:00 UTC daily, main branch): produces a CI-suffixed package +# and publishes it to the GitHub package registry. # -# Official Releases -# - Triggered after a GitHub Release is created -# - Version prefix applied from /src/Directory.Build.props -# - Version suffix applied from /src/Directory.Build.props -# - Package published to GitHub package registry -# - Package published to NuGet.org -# - Version prefix and/or suffix should be updated after each release +# - Push to `release/**`: every commit to a release branch produces a CI-suffixed +# package and publishes it to the GitHub package registry. +# +# - Manual `workflow_dispatch` (any branch): same outputs as a scheduled/push build; +# accepts a `version_suffix_override` input. +# +# - GitHub Release published (any branch's tag): publishes the version from +# `src/Directory.Build.props` to the GitHub package registry AND NuGet.org. +# +# Version +# - Version prefix and suffix come from `src/Directory.Build.props`. +# - For non-release triggers, the suffix is replaced with `ci.{run_number}` +# (or `workflow_dispatch.inputs.version_suffix_override` when provided). +# - The prefix and suffix in `Directory.Build.props` should be updated after each +# release using the `bump-version` or `prepare-release` skills. name: Release Publishing @@ -21,6 +26,10 @@ on: schedule: - cron: '0 7 * * *' + push: + branches: + - 'release/**' + workflow_dispatch: inputs: version_suffix_override: @@ -47,12 +56,12 @@ jobs: steps: - name: Clone the repo - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 with: fetch-depth: 0 # Shallow clones should be disabled for a better relevancy of analysis - name: Set up .NET - uses: actions/setup-dotnet@c2fa09f4bde5ebb9d1777cf28262a3eb3db3ced7 # v5.2.0 + uses: actions/setup-dotnet@a98b56852c35b8e3190ac28c8c2271da59106c68 # v6.0.0 with: dotnet-version: | 10.0.x @@ -75,10 +84,10 @@ jobs: version_suffix_args: ${{ github.event_name != 'release' && format('--version-suffix "{0}"', inputs.version_suffix_override || format('ci.{0}', github.run_number)) || '' }} steps: - - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 - name: Setup .NET - uses: actions/setup-dotnet@c2fa09f4bde5ebb9d1777cf28262a3eb3db3ced7 # v5.2.0 + uses: actions/setup-dotnet@a98b56852c35b8e3190ac28c8c2271da59106c68 # v6.0.0 with: dotnet-version: | 10.0.x @@ -105,10 +114,10 @@ jobs: packages: write steps: - - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 - name: Setup .NET - uses: actions/setup-dotnet@c2fa09f4bde5ebb9d1777cf28262a3eb3db3ced7 # v5.2.0 + uses: actions/setup-dotnet@a98b56852c35b8e3190ac28c8c2271da59106c68 # v6.0.0 with: dotnet-version: 10.0.x @@ -140,7 +149,7 @@ jobs: packages: write steps: - - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 - name: Download build artifacts uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1 @@ -160,10 +169,10 @@ jobs: permissions: { } steps: - - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2 + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 - name: Setup .NET - uses: actions/setup-dotnet@c2fa09f4bde5ebb9d1777cf28262a3eb3db3ced7 # v5.2.0 + uses: actions/setup-dotnet@a98b56852c35b8e3190ac28c8c2271da59106c68 # v6.0.0 with: dotnet-version: 10.0.x diff --git a/.gitignore b/.gitignore index 8d8db2cb4..a2ea2f790 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,9 @@ # Cake tools /[Tt]ools/ +# Language server cache +*.lscache + # Build output [Bb]uildArtifacts/ # Build results diff --git a/Directory.Build.props b/Directory.Build.props index f5cdd3aad..8bf83547e 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -11,30 +11,19 @@ - - - Debug - $([System.IO.Path]::GetFullPath('$(MSBuildThisFileDirectory)')) $([MSBuild]::NormalizeDirectory('$(RepoRoot)', 'artifacts')) $([MSBuild]::NormalizeDirectory('$(ArtifactsDir)', 'obj')) $([MSBuild]::NormalizeDirectory('$(ArtifactsDir)', 'bin')) - $([MSBuild]::NormalizeDirectory('$(ArtifactsDir)', 'TestResults', '$(Configuration)')) - $([MSBuild]::NormalizeDirectory('$(ArtifactsDir)', 'packages', '$(Configuration)')) $(MSBuildProjectName) $([System.IO.Path]::GetFullPath('$(ArtifactsObjDir)$(OutDirName)\')) - $(BaseIntermediateOutputPath)$(Configuration)\ $([System.IO.Path]::GetFullPath('$(ArtifactsBinDir)$(OutDirName)\')) - $(BaseOutputPath)$(Configuration)\ - - $(ArtifactsPackagesDir) trx%3bLogFileName=$(MSBuildProjectName).$(TargetFramework).$(OS).trx - $(ArtifactsTestResultsDir) diff --git a/Directory.Build.targets b/Directory.Build.targets new file mode 100644 index 000000000..d545f8be6 --- /dev/null +++ b/Directory.Build.targets @@ -0,0 +1,8 @@ + + + $([MSBuild]::NormalizeDirectory('$(ArtifactsDir)', 'TestResults', '$(Configuration)')) + $([MSBuild]::NormalizeDirectory('$(ArtifactsDir)', 'packages', '$(Configuration)')) + $(ArtifactsPackagesDir) + $(ArtifactsTestResultsDir) + + diff --git a/Directory.Packages.props b/Directory.Packages.props index 4caf048c6..69ed858b3 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -1,10 +1,10 @@ true - 8.0.22 - 9.0.11 - 10.0.7 - 10.5.2 + 8.0.29 + 9.0.18 + 10.0.10 + 10.8.3 @@ -25,6 +25,7 @@ + @@ -62,8 +63,9 @@ - - + + + runtime; build; native; contentfiles; analyzers; buildtransitive all @@ -74,24 +76,24 @@ - + - - - - - - + + + + + + - + - + diff --git a/ModelContextProtocol.slnx b/ModelContextProtocol.slnx index 1090c5377..9020d2fbe 100644 --- a/ModelContextProtocol.slnx +++ b/ModelContextProtocol.slnx @@ -1,11 +1,12 @@ - + + + - @@ -44,12 +45,13 @@ - + + @@ -66,6 +68,8 @@ + + diff --git a/README.md b/README.md index 7f5a9e14e..71902e4e8 100644 --- a/README.md +++ b/README.md @@ -6,7 +6,7 @@ The official C# SDK for the [Model Context Protocol](https://modelcontextprotoco ## Packages -This SDK consists of three main packages: +The SDK packages are: - **[ModelContextProtocol.Core](https://www.nuget.org/packages/ModelContextProtocol.Core)** [![NuGet version](https://img.shields.io/nuget/v/ModelContextProtocol.Core.svg)](https://www.nuget.org/packages/ModelContextProtocol.Core) - For projects that only need to use the client or low-level server APIs and want the minimum number of dependencies. @@ -14,6 +14,10 @@ This SDK consists of three main packages: - **[ModelContextProtocol.AspNetCore](https://www.nuget.org/packages/ModelContextProtocol.AspNetCore)** [![NuGet version](https://img.shields.io/nuget/v/ModelContextProtocol.AspNetCore.svg)](https://www.nuget.org/packages/ModelContextProtocol.AspNetCore) - The library for HTTP-based MCP servers. References `ModelContextProtocol`. +- **[ModelContextProtocol.Extensions.Apps](https://www.nuget.org/packages/ModelContextProtocol.Extensions.Apps)** [![NuGet version](https://img.shields.io/nuget/v/ModelContextProtocol.Extensions.Apps.svg)](https://www.nuget.org/packages/ModelContextProtocol.Extensions.Apps) - MCP Apps extension for building interactive UI applications that render inside MCP hosts. + +- **[ModelContextProtocol.Extensions.Tasks](https://www.nuget.org/packages/ModelContextProtocol.Extensions.Tasks)** [![NuGet version](https://img.shields.io/nuget/v/ModelContextProtocol.Extensions.Tasks.svg)](https://www.nuget.org/packages/ModelContextProtocol.Extensions.Tasks) - MCP Tasks extension for running long-running tool invocations asynchronously with status polling and input requests. + ## Getting Started To get started, see the [Getting Started](https://csharp.sdk.modelcontextprotocol.io/concepts/getting-started.html) guide in the conceptual documentation for installation instructions, package-selection guidance, and complete examples for both clients and servers. @@ -31,6 +35,11 @@ For more information about MCP: - [Protocol Specification](https://modelcontextprotocol.io/specification/) - [GitHub Organization](https://github.com/modelcontextprotocol) +## Cross-Application Access (Identity Assertion Authorization Grant flow) + +The SDK provides support for the [Identity Assertion Authorization Grant flow](https://github.com/modelcontextprotocol/ext-auth/blob/main/specification/draft/enterprise-managed-authorization.mdx) +via `IdentityAssertionGrantProvider`. See the [Cross-Application Access](docs/concepts/transports/transports.md#cross-application-access) section in the transport docs for full usage details. + ## License This project is licensed under the [Apache License 2.0](LICENSE). diff --git a/docs/concepts/apps/apps.md b/docs/concepts/apps/apps.md new file mode 100644 index 000000000..f22479966 --- /dev/null +++ b/docs/concepts/apps/apps.md @@ -0,0 +1,191 @@ +--- +title: MCP Apps +author: mikekistler +description: How to use the MCP Apps extension to deliver interactive UIs from MCP servers. +uid: apps +--- + +# MCP Apps + +[MCP Apps] is an extension to the Model Context Protocol that enables MCP servers to deliver interactive user interfaces — dashboards, forms, visualizations, and more — directly inside conversational AI clients. + +[MCP Apps]: https://modelcontextprotocol.io/extensions/apps/overview + +> [!IMPORTANT] +> MCP Apps support is experimental. All types are marked with `[Experimental("MCPEXP003")]` and require suppressing that diagnostic to use. + +## Installation + +MCP Apps is provided in the `ModelContextProtocol.Extensions.Apps` package, which layers on top of the core SDK: + +```shell +dotnet add package ModelContextProtocol.Extensions.Apps +``` + +## Overview + +The MCP Apps extension introduces the concept of **UI resources** — HTML pages served by the MCP server that a client can display alongside the conversation. Tools can be associated with a UI resource so the client knows which interface to show when a tool is called. + +The key concepts are: + +- **UI capability negotiation** — Client and server declare support via `extensions["io.modelcontextprotocol/ui"]` +- **UI resources** — HTML content served with the MIME type `text/html;profile=mcp-app` +- **Tool UI metadata** — Tools declare their associated UI resource in `_meta.ui` + +## Associating tools with UI resources + +### Using the builder extension (recommended) + +The simplest approach is to apply `[McpAppUi]` attributes to your tool methods and call `WithMcpApps()` on the server builder: + +```csharp +[McpServerToolType] +public class WeatherTools +{ + [McpServerTool, Description("Get current weather for a location")] + [McpAppUi(ResourceUri = "ui://weather/view.html")] + public static string GetWeather(string location) => $"Weather for {location}"; + + [McpServerTool, Description("Get forecast (model-only tool)")] + [McpAppUi(ResourceUri = "ui://weather/forecast.html", Visibility = [McpUiToolVisibility.Model])] + public static string GetForecast(string location) => $"Forecast for {location}"; +} +``` + +```csharp +builder.Services.AddMcpServer() + .WithTools() + .WithMcpApps(); +``` + +The `WithMcpApps()` call registers a post-configuration step that processes all registered tools and applies `[McpAppUi]` attribute metadata to their `_meta.ui` field automatically. + +### Using the attribute with manual processing + +If you create tools manually (without `WithMcpApps()`), you can still use the attribute and process tools explicitly: + +```csharp +var tools = new[] +{ + McpServerTool.Create(typeof(WeatherTools).GetMethod(nameof(WeatherTools.GetWeather))!), + McpServerTool.Create(typeof(WeatherTools).GetMethod(nameof(WeatherTools.GetForecast))!), +}; + +McpApps.ApplyAppUiAttributes(tools); +``` + +### Using the programmatic API + +For full control, use `McpApps.SetAppUi` to set UI metadata directly: + +```csharp +var tool = McpServerTool.Create((string location) => $"Weather for {location}"); + +McpApps.SetAppUi(tool, new McpUiToolMeta +{ + ResourceUri = "ui://weather/view.html", + Visibility = [McpUiToolVisibility.Model, McpUiToolVisibility.App], +}); +``` + +## Checking client capabilities + +During a session, you can check whether the connected client supports MCP Apps: + +```csharp +[McpServerTool, Description("Get weather")] +[McpAppUi(ResourceUri = "ui://weather/view.html")] +public static string GetWeather(McpServer server, string location) +{ + var uiCapability = McpApps.GetUiCapability(server.ClientCapabilities); + if (uiCapability is not null) + { + // Client supports MCP Apps — the UI will be displayed + } + + return $"Weather for {location}"; +} +``` + +## Tool visibility + +The `Visibility` property controls which principals can invoke the tool: + +| Value | Meaning | +|-----------------------------|----------------------------------------------------| +| `McpUiToolVisibility.Model` | Only the LLM can call this tool | +| `McpUiToolVisibility.App` | Only the app UI can call this tool | +| Both (or null/empty) | Both the model and app can call the tool (default) | + +## UI resources + +UI resources are HTML pages registered with the MCP server using the `ui://` URI scheme and the `text/html;profile=mcp-app` MIME type. The `McpUiResourceMeta` type provides metadata for these resources, including: + +- **CSP (Content Security Policy)** — Controls allowed origins for network requests and resource loads +- **Permissions** — Sandbox permissions (scripts, forms, popups, etc.) +- **Domain** — Dedicated origin for OAuth flows and CORS +- **PrefersBorder** — Whether the host should render a visual border + +## App-only tools + +Tools with `Visibility = [McpUiToolVisibility.App]` are not visible to the LLM — they are intended only for use by the app UI. +This is useful for tools that serve UI interaction (button handlers, form submissions) without cluttering the model's tool list: + +```csharp +[McpServerTool, Description("Submit the weather form")] +[McpAppUi(ResourceUri = "ui://weather/view.html", Visibility = [McpUiToolVisibility.App])] +public static string SubmitWeatherForm(string city) => GetWeatherHtml(city); +``` + +## Graceful degradation + +Not all clients support MCP Apps. Use `GetUiCapability` to detect support and return text-only content as a fallback: + +```csharp +[McpServerTool, Description("Get weather")] +[McpAppUi(ResourceUri = "ui://weather/view.html")] +public static string GetWeather(McpServer server, string location) +{ + var uiCapability = McpApps.GetUiCapability(server.ClientCapabilities); + if (uiCapability is null) + { + // Client doesn't support MCP Apps — return plain text + return $"Current weather for {location}: 72°F, sunny"; + } + + // Client supports MCP Apps — the UI resource will be displayed + return $"Weather data for {location} loaded into UI"; +} +``` + +## Display modes + +The MCP Apps spec defines display modes (`inline`, `fullscreen`, `pip`) that control how the host renders the UI. Display mode is negotiated between the client and server during capability exchange and is not set per-tool — it depends on the host implementation. + +## Host theming + +Hosts pass standardized CSS custom properties (for example, `--color-background-primary`, `--color-text-primary`) to app iframes. Your HTML can reference these variables to automatically match the host's theme without any server-side configuration. + +See the [MCP Apps specification](https://github.com/modelcontextprotocol/ext-apps/blob/main/specification/draft/apps.mdx) for the full list of CSS variables. + +## Single-file HTML bundling + +The default Content Security Policy restricts external script and style loads. For production apps, bundle all JavaScript and CSS into a single HTML file using tools like [vite-plugin-singlefile](https://github.com/richardtallent/vite-plugin-singlefile). For simple apps, inline ` + + diff --git a/scripts/finalize-docs-site.mjs b/scripts/finalize-docs-site.mjs new file mode 100644 index 000000000..d054952bb --- /dev/null +++ b/scripts/finalize-docs-site.mjs @@ -0,0 +1,138 @@ +// Finalize the combined multi-version docs site: +// * copy the picker assets to /assets/ +// * publish a cleaned docs-versions.json at the site root +// * write a root index.html that redirects to the default version +// * generate unversioned redirect pages for the deployed v1 documentation +// +// Usage: +// node scripts/finalize-docs-site.mjs [--versions ] + +import { readFile, writeFile, mkdir, copyFile, readdir } from "node:fs/promises"; +import path from "node:path"; +import { manifestPath } from "./manifest-path.mjs"; + +function parseArgs(argv) { + const positional = []; + const opts = {}; + for (let i = 0; i < argv.length; i++) { + const a = argv[i]; + if (a.startsWith("--")) opts[a.slice(2)] = argv[++i]; + else positional.push(a); + } + return { positional, opts }; +} + +function escapeHtml(s) { + return String(s).replace(/[&<>"']/g, (c) => + ({ "&": "&", "<": "<", ">": ">", '"': """, "'": "'" }[c]) + ); +} + +async function* htmlFiles(dir) { + for (const entry of await readdir(dir, { withFileTypes: true })) { + const full = path.join(dir, entry.name); + if (entry.isDirectory()) yield* htmlFiles(full); + else if (entry.isFile() && /\.html?$/i.test(entry.name)) yield full; + } +} + +function redirectPage(target, title) { + return ` + + + +${escapeHtml(title)} + + + + + +

Redirecting to ${escapeHtml(title)}…

+ + +`; +} + +async function generateV1Redirects(combinedDir) { + const v1Dir = path.join(combinedDir, "v1"); + const redirects = new Map(); + + for await (const sourceFile of htmlFiles(v1Dir)) { + const relativePath = path.relative(v1Dir, sourceFile).split(path.sep).join("/"); + if (relativePath === "index.html") continue; + + redirects.set(relativePath, `v1/${relativePath}`); + } + + const publicMap = {}; + const redirectEntries = [...redirects].sort(([left], [right]) => left.localeCompare(right)); + for (const [sourcePath, targetPath] of redirectEntries) { + const destination = path.join(combinedDir, sourcePath); + const relativeTarget = path.relative(path.dirname(destination), path.join(combinedDir, targetPath)) + .split(path.sep) + .join("/"); + + await mkdir(path.dirname(destination), { recursive: true }); + await writeFile(destination, redirectPage(relativeTarget, "MCP C# SDK documentation")); + publicMap[`/${sourcePath}`] = `/${targetPath}`; + } + + await writeFile( + path.join(combinedDir, "v1-redirects.json"), + JSON.stringify(publicMap, null, 2) + "\n" + ); + + return redirects.size; +} + +async function main() { + const { positional, opts } = parseArgs(process.argv.slice(2)); + const combinedDir = positional[0]; + if (!combinedDir) { + console.error("usage: finalize-docs-site.mjs [--versions ]"); + process.exit(2); + } + + const pickerDir = new URL("../docs/version-picker/", import.meta.url); + const versionsPath = opts.versions + ? path.resolve(opts.versions) + : manifestPath; + const manifest = JSON.parse(await readFile(versionsPath, "utf8")); + + // 1. Copy picker assets. + const assetsDir = path.join(combinedDir, "assets"); + await mkdir(assetsDir, { recursive: true }); + for (const name of ["version-picker.js", "version-picker.css"]) { + await copyFile(new URL(name, pickerDir), path.join(assetsDir, name)); + } + + // 2. Public docs-versions.json (drop build-only fields like `ref` and `$comment`). + const publicManifest = { + default: manifest.default, + versions: manifest.versions.map((v) => ({ + slug: v.slug, + label: v.label, + prerelease: !!v.prerelease, + })), + }; + await writeFile( + path.join(combinedDir, "docs-versions.json"), + JSON.stringify(publicManifest, null, 2) + "\n" + ); + + // 3. Root redirect to the default version (relative -> works under any base). + const def = manifest.default; + const target = `./${def}/`; + await writeFile( + path.join(combinedDir, "index.html"), + redirectPage(target, "MCP C# SDK documentation") + ); + + const redirectCount = await generateV1Redirects(combinedDir); + console.log(`[finalize] assets + docs-versions.json written; root redirects to ${target}; ${redirectCount} v1 redirects written`); +} + +main().catch((err) => { + console.error(err); + process.exit(1); +}); diff --git a/scripts/get-docs-version-slug.mjs b/scripts/get-docs-version-slug.mjs new file mode 100644 index 000000000..14aeebd7b --- /dev/null +++ b/scripts/get-docs-version-slug.mjs @@ -0,0 +1,21 @@ +// Print the docs URL slug for a source tree's VersionPrefix. +// +// Usage: +// node scripts/get-docs-version-slug.mjs + +import { readFile } from "node:fs/promises"; + +const propsPath = process.argv[2]; +if (!propsPath) { + console.error("usage: get-docs-version-slug.mjs "); + process.exit(2); +} + +const props = await readFile(propsPath, "utf8"); +const match = props.match(/\s*([1-9][0-9]*)\.\d+\.\d+\s*<\/VersionPrefix>/); +if (!match) { + console.error(`error: unable to determine VersionPrefix from ${propsPath}`); + process.exit(1); +} + +process.stdout.write(`v${match[1]}\n`); diff --git a/scripts/inject-version-picker.mjs b/scripts/inject-version-picker.mjs new file mode 100644 index 000000000..23623f182 --- /dev/null +++ b/scripts/inject-version-picker.mjs @@ -0,0 +1,116 @@ +// Inject the version-picker widget into every .html page of a built docs site. +// +// Usage: +// node scripts/inject-version-picker.mjs [--base /] [--versions ] +// +// is a single version's built output (e.g. combined/2.0). +// is that version's slug (must match an entry in docs-versions.json). +// The widget config is derived from docs-versions.json and written into each page's +// . The picker assets are referenced relative to each generated page so they +// work from both a custom domain and a project Pages subpath. + +import { readFile, writeFile, readdir } from "node:fs/promises"; +import { createHash } from "node:crypto"; +import path from "node:path"; +import { manifestPath } from "./manifest-path.mjs"; + +const MARKER = ""; + +function parseArgs(argv) { + const positional = []; + const opts = {}; + for (let i = 0; i < argv.length; i++) { + const a = argv[i]; + if (a.startsWith("--")) opts[a.slice(2)] = argv[++i]; + else positional.push(a); + } + return { positional, opts }; +} + +function normalizeBase(base) { + let b = (base || "/").trim(); + if (!b.startsWith("/")) b = "/" + b; + if (!b.endsWith("/")) b += "/"; + return b.replace(/\/{2,}/g, "/"); +} + +async function* htmlFiles(dir) { + for (const entry of await readdir(dir, { withFileTypes: true })) { + const full = path.join(dir, entry.name); + if (entry.isDirectory()) yield* htmlFiles(full); + else if (entry.isFile() && /\.html?$/i.test(entry.name)) yield full; + } +} + +async function assetRevision(name) { + const contents = await readFile(new URL(`../docs/version-picker/${name}`, import.meta.url)); + return createHash("sha256").update(contents).digest("hex").slice(0, 12); +} + +async function main() { + const { positional, opts } = parseArgs(process.argv.slice(2)); + const [siteDir, slug] = positional; + if (!siteDir || !slug) { + console.error("usage: inject-version-picker.mjs [--base /] [--versions ]"); + process.exit(2); + } + + const base = normalizeBase(opts.base); + const versionsPath = opts.versions + ? path.resolve(opts.versions) + : manifestPath; + const manifest = JSON.parse(await readFile(versionsPath, "utf8")); + + if (!manifest.versions.some((v) => v.slug === slug)) { + console.error(`error: slug "${slug}" is not present in docs-versions.json`); + process.exit(1); + } + + const config = { + version: slug, + base, + default: manifest.default, + versions: manifest.versions.map((v) => ({ + slug: v.slug, + label: v.label, + prerelease: !!v.prerelease, + })), + }; + + const json = JSON.stringify(config).replace(//i); + if (idx === -1) { + skipped++; + continue; + } + const assetBase = path.relative(path.dirname(file), assetsDir).split(path.sep).join("/") + "/"; + const snippet = + `\n${MARKER}\n` + + `\n` + + `\n` + + `\n`; + await writeFile(file, html.slice(0, idx) + snippet + html.slice(idx)); + injected++; + } + + console.log(`[inject] ${slug}: injected into ${injected} page(s), skipped ${skipped}`); +} + +main().catch((err) => { + console.error(err); + process.exit(1); +}); diff --git a/scripts/list-versions.mjs b/scripts/list-versions.mjs new file mode 100644 index 000000000..8c1ccfba2 --- /dev/null +++ b/scripts/list-versions.mjs @@ -0,0 +1,17 @@ +// Print the versions to build, one per line, as "\t". +// Consumed by the multi-version docs workflow to drive its build loop. +// +// Usage: node scripts/list-versions.mjs [--versions ] + +import { readFile } from "node:fs/promises"; +import path from "node:path"; +import { manifestPath } from "./manifest-path.mjs"; + +const arg = process.argv.slice(2); +const i = arg.indexOf("--versions"); +const versionsPath = i !== -1 ? path.resolve(arg[i + 1]) : manifestPath; + +const manifest = JSON.parse(await readFile(versionsPath, "utf8")); +for (const v of manifest.versions) { + process.stdout.write(`${v.slug}\t${v.ref}\n`); +} diff --git a/scripts/manifest-path.mjs b/scripts/manifest-path.mjs new file mode 100644 index 000000000..485509f91 --- /dev/null +++ b/scripts/manifest-path.mjs @@ -0,0 +1,16 @@ +// Location of the docs-versions manifest. +// +// This manifest is a build-time artifact produced during docs publishing, which +// only ever runs in CI -- never on a developer's machine. It therefore lives in +// the runner's temporary directory (RUNNER_TEMP on GitHub Actions, falling back +// to the OS temp dir for local testing) so it never touches the repository tree +// and needs no .gitignore entry. Every script agrees on this path, so the +// workflow does not need to thread it between steps. + +import os from "node:os"; +import path from "node:path"; + +export const manifestPath = path.join( + process.env.RUNNER_TEMP || os.tmpdir(), + "docs-versions.json" +); diff --git a/src/Common/Experimentals.cs b/src/Common/Experimentals.cs index 7e7e969bb..e61f84199 100644 --- a/src/Common/Experimentals.cs +++ b/src/Common/Experimentals.cs @@ -9,13 +9,14 @@ namespace ModelContextProtocol; /// Experimental diagnostic IDs are grouped by category: /// /// -/// MCPEXP001 covers APIs related to experimental features in the MCP specification itself, -/// such as Tasks and Extensions. These APIs may change as the specification evolves. +/// MCPEXP001 covers APIs related to experimental features in the MCP specification itself. +/// These APIs may change as the specification evolves. /// /// -/// MCPEXP002 covers experimental SDK APIs that are unrelated to the MCP specification, -/// such as subclassing internal types or SDK-specific extensibility hooks. These APIs may -/// change or be removed based on SDK design feedback. +/// MCPEXP002 covers SDK extensibility APIs that enable features to be implemented +/// in standalone packages without requiring Core to understand those features. The Tasks +/// package is one such consumer. These APIs remain experimental until additional +/// extensibility scenarios validate the design. /// /// /// @@ -36,67 +37,60 @@ namespace ModelContextProtocol; internal static class Experimentals { /// - /// Diagnostic ID for the experimental MCP Tasks feature. + /// Diagnostic ID for experimental MCP specification features. /// - public const string Tasks_DiagnosticId = "MCPEXP001"; - - /// - /// Message for the experimental MCP Tasks feature. - /// - public const string Tasks_Message = "The Tasks feature is experimental per the MCP specification and is subject to change."; - - /// - /// URL for the experimental MCP Tasks feature. - /// - public const string Tasks_Url = "https://github.com/modelcontextprotocol/csharp-sdk/blob/main/docs/list-of-diagnostics.md#mcpexp001"; + /// + /// When introducing a new experimental specification feature, add feature-specific message + /// and URL constants that use this diagnostic ID. + /// + public const string SpecificationFeature_DiagnosticId = "MCPEXP001"; /// - /// Diagnostic ID for the experimental MCP Extensions feature. + /// Diagnostic ID for experimental MCP Apps extension APIs. /// /// - /// This uses the same diagnostic ID as because both - /// Tasks and Extensions are covered by the same MCPEXP001 diagnostic for experimental - /// MCP features. Having separate constants improves code clarity while maintaining a - /// single diagnostic suppression point. + /// MCP Apps is the first official MCP extension ("io.modelcontextprotocol/ui"), enabling + /// servers to deliver interactive UIs inside AI clients. This uses a dedicated diagnostic ID + /// so that users can suppress it independently from other experimental APIs. /// - public const string Extensions_DiagnosticId = "MCPEXP001"; + public const string Apps_DiagnosticId = "MCPEXP003"; /// - /// Message for the experimental MCP Extensions feature. + /// Message for the experimental MCP Apps extension APIs. /// - public const string Extensions_Message = "The Extensions feature is part of a future MCP specification version that has not yet been ratified and is subject to change."; + public const string Apps_Message = "The MCP Apps extension is experimental and subject to change as the specification evolves."; /// - /// URL for the experimental MCP Extensions feature. + /// URL for the experimental MCP Apps extension APIs. /// - public const string Extensions_Url = "https://github.com/modelcontextprotocol/csharp-sdk/blob/main/docs/list-of-diagnostics.md#mcpexp001"; + public const string Apps_Url = "https://github.com/modelcontextprotocol/csharp-sdk/blob/main/docs/list-of-diagnostics.md#mcpexp003"; /// - /// Diagnostic ID for experimental SDK APIs unrelated to the MCP specification, - /// such as subclassing McpClient/McpServer or referencing RunSessionHandler. + /// Diagnostic ID for SDK extensibility APIs that enable independently packaged features, + /// such as Tasks, without requiring Core awareness of those features. /// /// /// This diagnostic ID covers experimental SDK-level extensibility APIs. All constants /// in this group share the same diagnostic ID so users need only one suppression point /// for SDK design preview features. /// - public const string Subclassing_DiagnosticId = "MCPEXP002"; + public const string Extensibility_DiagnosticId = "MCPEXP002"; /// - /// Message for experimental subclassing of McpClient and McpServer. + /// Message for experimental extensibility points in the C# SDK implementation. /// - public const string Subclassing_Message = "Subclassing McpClient and McpServer is experimental and subject to change."; + public const string Extensibility_Message = "This C# SDK extensibility API is experimental and subject to change."; /// - /// URL for experimental subclassing of McpClient and McpServer. + /// URL for experimental extensibility points in the C# SDK implementation. /// - public const string Subclassing_Url = "https://github.com/modelcontextprotocol/csharp-sdk/blob/main/docs/list-of-diagnostics.md#mcpexp002"; + public const string Extensibility_Url = "https://github.com/modelcontextprotocol/csharp-sdk/blob/main/docs/list-of-diagnostics.md#mcpexp002"; /// /// Diagnostic ID for the experimental RunSessionHandler API. /// /// - /// This uses the same diagnostic ID as because + /// This uses the same diagnostic ID as because /// both are experimental SDK APIs unrelated to the MCP specification. /// public const string RunSessionHandler_DiagnosticId = "MCPEXP002"; @@ -110,4 +104,5 @@ internal static class Experimentals /// URL for the experimental RunSessionHandler API. /// public const string RunSessionHandler_Url = "https://github.com/modelcontextprotocol/csharp-sdk/blob/main/docs/list-of-diagnostics.md#mcpexp002"; + } diff --git a/src/Common/HttpResponseMessageExtensions.cs b/src/Common/HttpResponseMessageExtensions.cs index 05ef092ac..d155e845a 100644 --- a/src/Common/HttpResponseMessageExtensions.cs +++ b/src/Common/HttpResponseMessageExtensions.cs @@ -23,25 +23,37 @@ public static async Task EnsureSuccessStatusCodeWithResponseBodyAsync(this HttpR { if (!response.IsSuccessStatusCode) { - string? responseBody = null; - try - { - using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken); - cts.CancelAfter(TimeSpan.FromSeconds(5)); - responseBody = await response.Content.ReadAsStringAsync(cts.Token).ConfigureAwait(false); + throw await CreateHttpRequestExceptionWithBodyAsync(response, cancellationToken).ConfigureAwait(false); + } + } - if (responseBody.Length > MaxResponseBodyLength) - { - responseBody = responseBody.Substring(0, MaxResponseBodyLength) + "..."; - } - } - catch + /// + /// Creates an for a non-success response, making a best-effort attempt to + /// include the server's response body in the exception message so the diagnostic isn't lost. + /// + /// The non-success HTTP response message. + /// The token to monitor for cancellation requests. + /// An with the response status and, when available, its body. + public static async Task CreateHttpRequestExceptionWithBodyAsync(HttpResponseMessage response, CancellationToken cancellationToken = default) + { + string? responseBody = null; + try + { + using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken); + cts.CancelAfter(TimeSpan.FromSeconds(5)); + responseBody = await response.Content.ReadAsStringAsync(cts.Token).ConfigureAwait(false); + + if (responseBody.Length > MaxResponseBodyLength) { - // Ignore all errors reading the response body (e.g., stream closed, timeout, cancellation) - we'll throw without it. + responseBody = responseBody.Substring(0, MaxResponseBodyLength) + "..."; } - - throw CreateHttpRequestException(response, responseBody); } + catch + { + // Ignore all errors reading the response body (e.g., stream closed, timeout, cancellation) - we'll throw without it. + } + + return CreateHttpRequestException(response, responseBody); } /// @@ -57,10 +69,52 @@ public static HttpRequestException CreateHttpRequestException(HttpResponseMessag ? $"Response status code does not indicate success: {statusCodeInt} ({response.ReasonPhrase})." : $"Response status code does not indicate success: {statusCodeInt} ({response.ReasonPhrase}). Response body: {responseBody}"; + return HttpRequestExceptionExtensions.Create(message, innerException: null, response.StatusCode); + } +} + +/// +/// Helpers for preserving HTTP status codes on across all target frameworks. +/// +internal static class HttpRequestExceptionExtensions +{ + internal const string StatusCodeDataKey = "ModelContextProtocol.HttpStatusCode"; + + /// + /// Creates an and preserves its HTTP status code. + /// + public static HttpRequestException Create(string message, Exception? innerException, HttpStatusCode? statusCode) + { #if NET - return new HttpRequestException(message, inner: null, response.StatusCode); + var exception = new HttpRequestException(message, innerException, statusCode); #else - return new HttpRequestException(message); + var exception = new HttpRequestException(message, innerException); #endif + + if (statusCode is not null) + { + exception.Data[StatusCodeDataKey] = statusCode.Value; + } + + return exception; + } + + /// + /// Gets the preserved HTTP status code from an . + /// + public static HttpStatusCode? GetStatusCode(this HttpRequestException exception) + { +#if NET + if (exception.StatusCode is { } statusCode) + { + return statusCode; + } +#endif + + return exception.Data[StatusCodeDataKey] switch + { + HttpStatusCode storedStatusCode => storedStatusCode, + _ => null, + }; } } diff --git a/src/Common/McpHttpHeaders.cs b/src/Common/McpHttpHeaders.cs new file mode 100644 index 000000000..c08326e20 --- /dev/null +++ b/src/Common/McpHttpHeaders.cs @@ -0,0 +1,55 @@ +namespace ModelContextProtocol.Protocol; + +/// +/// Constants for MCP-specific HTTP header names used in the Streamable HTTP transport. +/// +/// +/// Per RFC 9110, HTTP header names are case-insensitive. Clients and servers must +/// use case-insensitive comparisons when processing these headers. +/// +internal static class McpHttpHeaders +{ + /// The session identifier header. + public const string SessionId = "Mcp-Session-Id"; + + /// The negotiated protocol version header. + public const string ProtocolVersion = "MCP-Protocol-Version"; + + /// The last event ID for SSE stream resumption. + public const string LastEventId = "Last-Event-ID"; + + /// + /// The JSON-RPC method being invoked (e.g., "tools/call", "resources/read"). + /// + /// + /// Required on all Streamable HTTP POST requests. The value must match the method + /// field in the JSON-RPC request body. + /// + public const string Method = "Mcp-Method"; + + /// + /// The name or URI of the target resource for the request. + /// + /// + /// Required for tools/call, resources/read, and prompts/get requests. + /// For tools/call and prompts/get, the value is taken from params.name. + /// For resources/read, the value is taken from params.uri. + /// + public const string Name = "Mcp-Name"; + + /// + /// Prefix for custom parameter headers (Mcp-Param-{Name}). + /// + /// + /// When a tool's inputSchema includes properties annotated with x-mcp-header, + /// clients mirror those parameter values into HTTP headers using this prefix. + /// + public const string ParamPrefix = "Mcp-Param-"; + + /// + /// Key used in to store the tool + /// definition for the current request, enabling the transport to add custom parameter headers. + /// + internal const string ToolContextKey = "Mcp.Tool"; + +} diff --git a/src/Common/McpProtocolVersions.cs b/src/Common/McpProtocolVersions.cs new file mode 100644 index 000000000..09b1f5b3d --- /dev/null +++ b/src/Common/McpProtocolVersions.cs @@ -0,0 +1,113 @@ +namespace ModelContextProtocol.Protocol; + +/// +/// Internal helpers for MCP protocol revision strings and protocol-era behavior gates. +/// +internal static class McpProtocolVersions +{ + /// + /// The 2026-07-28 MCP protocol revision (SEP-2575 + SEP-2567). It removed the initialize + /// handshake and Mcp-Session-Id, so Streamable HTTP no longer has sessions; it also enabled + /// MRTR (SEP-2322) and made the standard MCP request headers (Mcp-Method, Mcp-Name) + /// required. Behaviors that began at this revision are gated by ordinal-comparing the per-request + /// version against it (see ), so it underpins the more + /// semantically named helpers. It is also the latest revision this SDK supports, so clients prefer it + /// by default. + /// + public const string July2026ProtocolVersion = "2026-07-28"; + + /// + /// The 2025-11-25 MCP protocol revision: the latest revision that still supports Streamable HTTP + /// sessions (the initialize handshake and Mcp-Session-Id); newer revisions remove them. + /// It is the default version for the initialize and session-resume code paths, and the version + /// the server advertises when a peer requests an unsupported version on the initialize handshake. + /// + public const string November2025ProtocolVersion = "2025-11-25"; + + /// The 2025-06-18 MCP protocol revision. + public const string June2025ProtocolVersion = "2025-06-18"; + + /// The 2025-03-26 MCP protocol revision. + public const string March2025ProtocolVersion = "2025-03-26"; + + /// The 2024-11-05 MCP protocol revision. + public const string November2024ProtocolVersion = "2024-11-05"; + + /// + /// Protocol versions that still use the initialize handshake. + /// + internal static readonly string[] InitializeHandshakeProtocolVersions = + [ + November2024ProtocolVersion, + March2025ProtocolVersion, + June2025ProtocolVersion, + November2025ProtocolVersion, + ]; + + /// + /// Protocol versions that use per-request metadata instead of the initialize handshake. + /// + internal static readonly string[] PerRequestMetadataProtocolVersions = + [ + July2026ProtocolVersion, + ]; + + /// + /// All protocol versions supported by this implementation. + /// + internal static readonly string[] SupportedProtocolVersions = + [ + .. InitializeHandshakeProtocolVersions, + .. PerRequestMetadataProtocolVersions, + ]; + + /// + /// Returns if the given protocol version is + /// or later, the revision that removed the initialize handshake and Streamable HTTP sessions. + /// Protocol versions are ISO-8601 dates, so an ordinal comparison orders them chronologically. + /// + internal static bool IsJuly2026OrLaterProtocolVersion(string? protocolVersion) + => !string.IsNullOrEmpty(protocolVersion) + && StringComparer.Ordinal.Compare(protocolVersion, July2026ProtocolVersion) >= 0; + + /// + /// Returns if the given protocol version is supported by this implementation. + /// + internal static bool IsSupportedProtocolVersion(string? protocolVersion) + => protocolVersion is not null && SupportedProtocolVersions.Contains(protocolVersion); + + /// + /// Returns if the given protocol version is available through the + /// initialize handshake. + /// + internal static bool SupportsInitializeHandshake(string? protocolVersion) + => protocolVersion is not null && InitializeHandshakeProtocolVersions.Contains(protocolVersion); + + /// + /// Returns if the given protocol version requires the handshake-free + /// per-request metadata path. + /// + internal static bool RequiresPerRequestMetadata(string? protocolVersion) + => IsJuly2026OrLaterProtocolVersion(protocolVersion); + + /// + /// Returns if the given protocol version requires standard MCP request headers + /// (Mcp-Method, Mcp-Name). + /// + internal static bool RequiresStandardHeaders(string? protocolVersion) + => RequiresPerRequestMetadata(protocolVersion); + + /// + /// Returns if the given protocol version supports Streamable HTTP sessions. + /// + internal static bool SupportsHttpSessions(string? protocolVersion) + => !RequiresPerRequestMetadata(protocolVersion); + + /// + /// Returns if the negotiated protocol version reports unresolvable + /// resource URIs with the standard JSON-RPC (-32602) + /// rather than the legacy (-32002). + /// + internal static bool UseInvalidParamsForMissingResource(string? protocolVersion) + => IsJuly2026OrLaterProtocolVersion(protocolVersion); +} diff --git a/src/Common/Obsoletions.cs b/src/Common/Obsoletions.cs index 46ea782d8..217ff97ea 100644 --- a/src/Common/Obsoletions.cs +++ b/src/Common/Obsoletions.cs @@ -28,9 +28,26 @@ internal static class Obsoletions public const string RequestContextParamsConstructor_DiagnosticId = "MCP9003"; public const string RequestContextParamsConstructor_Message = "Use the constructor overload that accepts a parameters argument."; - public const string RequestContextParamsConstructor_Url = "https://github.com/modelcontextprotocol/csharp-sdk/blob/main/docs/list-of-diagnostics.md#mcp9003"; + public const string RequestContextParamsConstructor_Url = "https://github.com/modelcontextprotocol/csharp-sdk/blob/main/docs/list-of-diagnostics.md#obsolete-apis"; public const string EnableLegacySse_DiagnosticId = "MCP9004"; public const string EnableLegacySse_Message = "Legacy SSE transport has no built-in request backpressure and should only be used with completely trusted clients in isolated processes. Use Streamable HTTP instead."; public const string EnableLegacySse_Url = "https://github.com/modelcontextprotocol/csharp-sdk/blob/main/docs/list-of-diagnostics.md#obsolete-apis"; + + // SEP-2577 deprecates the Roots, Sampling, and Logging features as a single coordinated + // deprecation. They share one diagnostic ID (MCP9005) so consumers can opt out with a single + // suppression, while the feature-specific messages keep the diagnostics distinguishable. + public const string Deprecated_DiagnosticId = "MCP9005"; + public const string Deprecated_Url = "https://github.com/modelcontextprotocol/csharp-sdk/blob/main/docs/list-of-diagnostics.md#obsolete-apis"; + public const string DeprecatedRoots_Message = "The Roots feature is deprecated as of specification version 2026-07-28 and may be removed in a future version. See SEP-2577 for more information."; + public const string DeprecatedSampling_Message = "The Sampling feature is deprecated as of specification version 2026-07-28 and may be removed in a future version. See SEP-2577 for more information."; + public const string DeprecatedLogging_Message = "The Logging feature is deprecated as of specification version 2026-07-28 and may be removed in a future version. See SEP-2577 for more information."; + + public const string LegacyStatefulHttp_DiagnosticId = "MCP9006"; + public const string LegacyStatefulHttp_Message = "Stateful Streamable HTTP mode is a back-compat-only escape hatch for 2025-11-25 protocol revision clients and earlier. Set HttpServerTransportOptions.SessionMode = HttpServerSessionMode.Stateless (the default as of the 2026-07-28 protocol revision) for new code. See SEP-2567."; + public const string LegacyStatefulHttp_Url = "https://github.com/modelcontextprotocol/csharp-sdk/blob/main/docs/list-of-diagnostics.md#obsolete-apis"; + + public const string AuthorizationRedirectDelegate_DiagnosticId = "MCP9007"; + public const string AuthorizationRedirectDelegate_Message = "AuthorizationRedirectDelegate cannot provide the RFC 9207 issuer and is retained for compatibility only. Use AuthorizationCallbackHandler instead."; + public const string AuthorizationRedirectDelegate_Url = "https://github.com/modelcontextprotocol/csharp-sdk/blob/main/docs/list-of-diagnostics.md#obsolete-apis"; } diff --git a/src/Directory.Build.props b/src/Directory.Build.props index 21be76a9e..2b120c434 100644 --- a/src/Directory.Build.props +++ b/src/Directory.Build.props @@ -5,7 +5,8 @@ https://csharp.sdk.modelcontextprotocol.io https://github.com/modelcontextprotocol/csharp-sdk git - 1.3.0 + 2.2.0 + ModelContextProtocol © Model Context Protocol a Series of LF Projects, LLC. ModelContextProtocol;mcp;ai;llm @@ -17,7 +18,7 @@ $(RepoRoot)\Open.snk true true - 1.0.0 + 2.0.0 diff --git a/src/Directory.Build.targets b/src/Directory.Build.targets new file mode 100644 index 000000000..0c3c50923 --- /dev/null +++ b/src/Directory.Build.targets @@ -0,0 +1,15 @@ + + + + + + <_ProjectReferencesWithVersions Update="@(_ProjectReferencesWithVersions)"> + [%(_ProjectReferencesWithVersions.ProjectVersion)] + + + + diff --git a/src/ModelContextProtocol.AspNetCore/AuthorizationCallToolFilterGuardSetup.cs b/src/ModelContextProtocol.AspNetCore/AuthorizationCallToolFilterGuardSetup.cs new file mode 100644 index 000000000..8f41a5bd3 --- /dev/null +++ b/src/ModelContextProtocol.AspNetCore/AuthorizationCallToolFilterGuardSetup.cs @@ -0,0 +1,32 @@ +using Microsoft.Extensions.Options; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; + +namespace ModelContextProtocol.AspNetCore; + +internal sealed class AuthorizationFiltersMarker; + +internal sealed class AuthorizationCallToolFilterGuardSetup(AuthorizationFiltersMarker? marker = null) : IPostConfigureOptions +{ + public void PostConfigure(string? name, McpServerOptions options) + { + if (marker is not null) + { + return; + } + +#pragma warning disable MCPEXP002 // The guard must run before Tasks can dispatch the request. + options.Filters.Request.CallToolWithAlternateFilters.Insert(0, static async (context, next, cancellationToken) => + { + if (AuthorizationFilterSetup.HasAuthorizationMetadata(context.MatchedPrimitive)) + { + throw new InvalidOperationException( + "Authorization filter was not invoked for tools/call operation, but authorization metadata was found on the tool. " + + "Ensure that AddAuthorizationFilters() is called on the IMcpServerBuilder to configure authorization filters."); + } + + return await next(context, cancellationToken); + }); +#pragma warning restore MCPEXP002 + } +} diff --git a/src/ModelContextProtocol.AspNetCore/AuthorizationFilterSetup.cs b/src/ModelContextProtocol.AspNetCore/AuthorizationFilterSetup.cs index 3f5870700..6290dd5c6 100644 --- a/src/ModelContextProtocol.AspNetCore/AuthorizationFilterSetup.cs +++ b/src/ModelContextProtocol.AspNetCore/AuthorizationFilterSetup.cs @@ -11,14 +11,16 @@ namespace ModelContextProtocol.AspNetCore; /// /// Evaluates authorization policies from endpoint metadata. /// -internal sealed class AuthorizationFilterSetup(IAuthorizationPolicyProvider? policyProvider = null) : IConfigureOptions, IPostConfigureOptions +internal sealed class AuthorizationFilterSetup( + IAuthorizationPolicyProvider? policyProvider = null, + AuthorizationFiltersMarker? marker = null) : IConfigureOptions, IPostConfigureOptions { private static readonly string AuthorizationFilterInvokedKey = "ModelContextProtocol.AspNetCore.AuthorizationFilter.Invoked"; public void Configure(McpServerOptions options) { ConfigureListToolsFilter(options); - ConfigureCallToolFilter(options); + ConfigureOrdinaryCallToolFilter(options); ConfigureListResourcesFilter(options); ConfigureListResourceTemplatesFilter(options); @@ -30,8 +32,13 @@ public void Configure(McpServerOptions options) public void PostConfigure(string? name, McpServerOptions options) { + // Add tool authorization after all regular configuration so it always wraps Tasks. + if (marker is not null) + { + ConfigureCallToolFilter(options); + } + CheckListToolsFilter(options); - CheckCallToolFilter(options); CheckListResourcesFilter(options); CheckListResourceTemplatesFilter(options); @@ -79,7 +86,7 @@ private static void CheckListToolsFilter(McpServerOptions options) }); } - private void ConfigureCallToolFilter(McpServerOptions options) + private void ConfigureOrdinaryCallToolFilter(McpServerOptions options) { options.Filters.Request.CallToolFilters.Add(next => async (context, cancellationToken) => { @@ -95,18 +102,22 @@ private void ConfigureCallToolFilter(McpServerOptions options) }); } - private static void CheckCallToolFilter(McpServerOptions options) + private void ConfigureCallToolFilter(McpServerOptions options) { - options.Filters.Request.CallToolFilters.Add(next => async (context, cancellationToken) => +#pragma warning disable MCPEXP002 // Authorization must run in the alternate-result pipeline before task dispatch. + options.Filters.Request.CallToolWithAlternateFilters.Insert(0, async (context, next, cancellationToken) => { - if (HasAuthorizationMetadata(context.MatchedPrimitive) - && !context.Items.ContainsKey(AuthorizationFilterInvokedKey)) + var authResult = await GetAuthorizationResultAsync(context.User, context.MatchedPrimitive, context.Services, context); + if (!authResult.Succeeded) { - throw new InvalidOperationException("Authorization filter was not invoked for tools/call operation, but authorization metadata was found on the tool. Ensure that AddAuthorizationFilters() is called on the IMcpServerBuilder to configure authorization filters."); + throw new McpProtocolException("Access forbidden: This tool requires authorization.", McpErrorCode.InvalidRequest); } + context.Items[AuthorizationFilterInvokedKey] = true; + return await next(context, cancellationToken); }); +#pragma warning restore MCPEXP002 } private void ConfigureListResourcesFilter(McpServerOptions options) @@ -374,7 +385,7 @@ private async ValueTask GetAuthorizationResultAsync( : AuthorizationPolicy.Combine(policy, reqPolicyBuilder.Build()); } - private static bool HasAuthorizationMetadata([NotNullWhen(true)] IMcpServerPrimitive? primitive) + internal static bool HasAuthorizationMetadata([NotNullWhen(true)] IMcpServerPrimitive? primitive) { // If no primitive was found for this request or there is IAllowAnonymous metadata anywhere on the class or method, // the request should go through as normal. diff --git a/src/ModelContextProtocol.AspNetCore/DistributedCacheEventStreamStoreOptionsSetup.cs b/src/ModelContextProtocol.AspNetCore/DistributedCacheEventStreamStoreOptionsSetup.cs index 9433eea7e..c3293a5c6 100644 --- a/src/ModelContextProtocol.AspNetCore/DistributedCacheEventStreamStoreOptionsSetup.cs +++ b/src/ModelContextProtocol.AspNetCore/DistributedCacheEventStreamStoreOptionsSetup.cs @@ -4,6 +4,8 @@ namespace ModelContextProtocol.AspNetCore; +#pragma warning disable MCP9006 // This type only exists to configure the obsolete legacy resumability store. + /// /// Configures by resolving /// the from DI when not explicitly set. diff --git a/src/ModelContextProtocol.AspNetCore/DistributedCacheEventStreamStoreOptionsValidator.cs b/src/ModelContextProtocol.AspNetCore/DistributedCacheEventStreamStoreOptionsValidator.cs index 1b4786163..47c51f07a 100644 --- a/src/ModelContextProtocol.AspNetCore/DistributedCacheEventStreamStoreOptionsValidator.cs +++ b/src/ModelContextProtocol.AspNetCore/DistributedCacheEventStreamStoreOptionsValidator.cs @@ -5,6 +5,8 @@ namespace ModelContextProtocol.AspNetCore; +#pragma warning disable MCP9006 // This type only exists to validate the obsolete legacy resumability store options. + /// /// Validates that is set. /// diff --git a/src/ModelContextProtocol.AspNetCore/HttpMcpServerBuilderExtensions.cs b/src/ModelContextProtocol.AspNetCore/HttpMcpServerBuilderExtensions.cs index bcdf53584..a52268341 100644 --- a/src/ModelContextProtocol.AspNetCore/HttpMcpServerBuilderExtensions.cs +++ b/src/ModelContextProtocol.AspNetCore/HttpMcpServerBuilderExtensions.cs @@ -34,6 +34,7 @@ public static IMcpServerBuilder WithHttpTransport(this IMcpServerBuilder builder builder.Services.AddHostedService(); builder.Services.TryAddEnumerable(ServiceDescriptor.Transient, AuthorizationFilterSetup>()); + builder.Services.TryAddEnumerable(ServiceDescriptor.Transient, AuthorizationCallToolFilterGuardSetup>()); builder.Services.TryAddEnumerable(ServiceDescriptor.Transient, HttpServerTransportOptionsSetup>()); if (configureOptions is not null) @@ -55,14 +56,20 @@ public static IMcpServerBuilder WithHttpTransport(this IMcpServerBuilder builder /// /// This method automatically configures authorization filters for all MCP server handlers. These filters respect /// authorization attributes such as - /// and . + /// and . Tool authorization runs in the alternate-result pipeline before + /// the Tasks extension dispatches background execution, so an unauthorized tool call does not create a task. + /// Each call to this method also adds an ordinary call-tool authorization checkpoint at that point in the filter + /// pipeline. Call this method again after any call-tool filter that changes the matched tool or user to authorize + /// the replacement using the updated context. /// public static IMcpServerBuilder AddAuthorizationFilters(this IMcpServerBuilder builder) { ArgumentNullException.ThrowIfNull(builder); // Allow the authorization filters to get added multiple times in case other middleware changes the matched primitive. + builder.Services.TryAddSingleton(); builder.Services.AddTransient, AuthorizationFilterSetup>(); + builder.Services.TryAddEnumerable(ServiceDescriptor.Transient, AuthorizationFilterSetup>()); return builder; } @@ -84,6 +91,8 @@ public static IMcpServerBuilder AddAuthorizationFilters(this IMcpServerBuilder b /// set the property in the callback. /// /// + [Obsolete(ModelContextProtocol.Obsoletions.LegacyStatefulHttp_Message, DiagnosticId = ModelContextProtocol.Obsoletions.LegacyStatefulHttp_DiagnosticId, UrlFormat = ModelContextProtocol.Obsoletions.LegacyStatefulHttp_Url)] +#pragma warning disable MCP9006 // The method is itself obsolete and intentionally wires up the legacy resumability store. public static IMcpServerBuilder WithDistributedCacheEventStreamStore(this IMcpServerBuilder builder, Action? configureOptions = null) { ArgumentNullException.ThrowIfNull(builder); @@ -99,4 +108,5 @@ public static IMcpServerBuilder WithDistributedCacheEventStreamStore(this IMcpSe return builder; } +#pragma warning restore MCP9006 } diff --git a/src/ModelContextProtocol.AspNetCore/HttpServerSessionMode.cs b/src/ModelContextProtocol.AspNetCore/HttpServerSessionMode.cs new file mode 100644 index 000000000..829b7e83b --- /dev/null +++ b/src/ModelContextProtocol.AspNetCore/HttpServerSessionMode.cs @@ -0,0 +1,64 @@ +using ModelContextProtocol.Server; + +namespace ModelContextProtocol.AspNetCore; + +/// +/// Specifies how the Streamable HTTP transport tracks state between requests. +/// +/// +/// Starting with the 2026-07-28 protocol revision, Streamable HTTP no longer supports sessions +/// (SEP-2567 removed Mcp-Session-Id, and SEP-2575 removed the initialize handshake), so requests +/// using that revision or later can only ever be served statelessly. This enumeration allows specification for +/// how the server reconciles that requirement with clients that still rely on the initialize handshake. +/// +public enum HttpServerSessionMode +{ + /// + /// The server never tracks state between requests, allowing for load balancing without session affinity. + /// + /// + /// is , the + /// Mcp-Session-Id header is unused, and + /// are invoked once per request, and the + /// GET, DELETE, and /sse endpoints are unavailable. Unsolicited server-to-client messages and all + /// server-to-client requests are unsupported because any response might arrive at another ASP.NET Core + /// application process. Client sampling, elicitation, and roots capabilities are disabled because the + /// server cannot make requests; use Multi Round-Trip Requests (MRTR) + /// instead. + /// + Stateless, + + /// + /// The server tracks a long-lived session for every client, which requires session affinity. + /// + /// + /// Requests using the 2026-07-28 or later protocol revision are refused with a + /// -32022 UnsupportedProtocolVersion error so that a dual-path client downgrades to the + /// initialize handshake and obtains the session the server was configured to provide. Use + /// to serve those clients natively instead of forcing a downgrade. + /// + Stateful, + + /// + /// The server tracks a long-lived session for clients that use the initialize handshake and serves + /// clients using the 2026-07-28 or later protocol revision statelessly on the same endpoint. + /// + /// + /// + /// This hybrid mode allows an application to adopt the latest protocol revision progressively rather than + /// waiting for every client to migrate. Clients using the 2025-11-25 or earlier revisions get a full + /// stateful session with an Mcp-Session-Id and continue to use the GET and DELETE endpoints, while + /// clients using the 2026-07-28 or later revisions are served per request with no session ID minted + /// or echoed, and receive 405 Method Not Allowed for GET and DELETE, exactly as in + /// mode. + /// + /// + /// Because a 2026-07-28 request has no session, the session-only features listed on + /// remain unavailable to those clients even though other clients on the same + /// endpoint have sessions. is invoked once + /// per session for initialize-handshake clients and once per request for 2026-07-28 and later + /// clients. + /// + /// + StatefulForInitializeClients, +} diff --git a/src/ModelContextProtocol.AspNetCore/HttpServerTransportOptions.cs b/src/ModelContextProtocol.AspNetCore/HttpServerTransportOptions.cs index 648cb86df..7ecfc0748 100644 --- a/src/ModelContextProtocol.AspNetCore/HttpServerTransportOptions.cs +++ b/src/ModelContextProtocol.AspNetCore/HttpServerTransportOptions.cs @@ -1,4 +1,4 @@ -using Microsoft.AspNetCore.Http; +using Microsoft.AspNetCore.Http; using ModelContextProtocol.Server; namespace ModelContextProtocol.AspNetCore; @@ -18,9 +18,11 @@ public class HttpServerTransportOptions /// with access to the of the request that initiated the session. /// /// - /// In stateful mode (the default), this callback is invoked once per session when the client sends the - /// initialize request. In mode, it is invoked on every HTTP request - /// because each request creates a fresh server context. + /// In stateful mode, this callback is invoked once per session when the client sends the + /// initialize request. In mode, it is invoked on + /// every HTTP request because each request creates a fresh server context. In + /// mode, both apply: once per session for + /// initialize-handshake clients and once per request for 2026-07-28 and later clients. /// public Func? ConfigureSessionOptions { get; set; } @@ -39,27 +41,78 @@ public class HttpServerTransportOptions /// of the initializing request with fewer known issues. /// /// + /// In mode, this callback is invoked once per session. In + /// mode, it is invoked once per HTTP request. In + /// mode, both apply: once per session for + /// initialize-handshake clients and once per request for 2026-07-28 and later clients. + /// + /// /// This API is experimental and may be removed or change signatures in a future release. /// /// [System.Diagnostics.CodeAnalysis.Experimental(Experimentals.RunSessionHandler_DiagnosticId, UrlFormat = Experimentals.RunSessionHandler_Url)] public Func? RunSessionHandler { get; set; } + /// + /// Gets or sets a value that indicates how the server tracks state between requests. + /// + /// + /// One of the values. The default is + /// as of the 2026-07-28 protocol revision (SEP-2567). + /// + /// + /// + /// doesn't track state between requests, allowing for load + /// balancing without session affinity. will be null, the + /// "MCP-Session-Id" header will not be used, the will be called once for + /// each request, and the GET, DELETE, and "/sse" endpoints will be disabled. Unsolicited server-to-client + /// messages and all server-to-client requests are also unsupported, because any responses might arrive at + /// another ASP.NET Core application process. Client sampling, elicitation, and roots capabilities are also + /// disabled, because the server cannot make requests. + /// + /// + /// tracks a session for every client, which requires session + /// affinity. Starting with the 2026-07-28 protocol revision, Streamable HTTP no longer supports + /// sessions: the revision removed Mcp-Session-Id (SEP-2567), so such a request is refused with a + /// -32022 UnsupportedProtocolVersion error, and a dual-path client downgrades to the + /// initialize handshake and obtains the session the server was configured to provide. + /// + /// + /// avoids that downgrade by serving + /// 2026-07-28 and later requests statelessly on the same endpoint while initialize-handshake + /// clients still get full sessions. Session-only features remain unavailable to the stateless half of the + /// endpoint; use MRTR for + /// elicitation there. + /// + /// + /// A request that carries an Mcp-Session-Id on the 2026-07-28 and later revisions is ignored + /// in every mode; the server must not mint or echo session IDs for those revisions. + /// + /// + public HttpServerSessionMode SessionMode { get; set; } = HttpServerSessionMode.Stateless; + /// /// Gets or sets a value that indicates whether the server runs in a stateless mode that doesn't track state between requests, /// allowing for load balancing without session affinity. /// /// - /// if the server runs in a stateless mode; if the server tracks state between requests. The default is . + /// if the server runs in a stateless mode; if the server tracks state between requests. + /// The default is as of the 2026-07-28 protocol revision (SEP-2567); + /// set to only when you need to support legacy clients that rely on session affinity. /// /// - /// If , will be null, and the "MCP-Session-Id" header will not be used, - /// the will be called once for each request, and the "/sse" endpoint will be disabled. - /// Unsolicited server-to-client messages and all server-to-client requests are also unsupported, because any responses - /// might arrive at another ASP.NET Core application process. - /// Client sampling, elicitation, and roots capabilities are also disabled in stateless mode, because the server cannot make requests. + /// This property is a convenience proxy over . Reading it returns + /// only when is , + /// so reads as . + /// Assigning selects and assigning + /// selects . Because both properties + /// update the same underlying value, the last assignment wins when both are configured. /// - public bool Stateless { get; set; } + public bool Stateless + { + get => SessionMode is HttpServerSessionMode.Stateless; + set => SessionMode = value ? HttpServerSessionMode.Stateless : HttpServerSessionMode.Stateful; + } /// /// Gets or sets a value that indicates whether the server maps legacy SSE endpoints (/sse and /message) @@ -83,8 +136,9 @@ public class HttpServerTransportOptions /// built-in backpressure. /// /// - /// Setting this to while is also - /// throws an at startup, because SSE requires in-memory session state. + /// Setting this to while is + /// throws an at + /// startup, because SSE requires in-memory session state. /// /// /// This property can also be enabled via the ModelContextProtocol.AspNetCore.EnableLegacySse @@ -112,6 +166,7 @@ public class HttpServerTransportOptions /// If this property is not set, the server will attempt to resolve an from DI. /// /// + [Obsolete(Obsoletions.LegacyStatefulHttp_Message, DiagnosticId = Obsoletions.LegacyStatefulHttp_DiagnosticId, UrlFormat = Obsoletions.LegacyStatefulHttp_Url)] public ISseEventStreamStore? EventStreamStore { get; set; } /// @@ -128,6 +183,7 @@ public class HttpServerTransportOptions /// If this property is not set, the server will attempt to resolve an from DI. /// /// + [Obsolete(Obsoletions.LegacyStatefulHttp_Message, DiagnosticId = Obsoletions.LegacyStatefulHttp_DiagnosticId, UrlFormat = Obsoletions.LegacyStatefulHttp_Url)] public ISessionMigrationHandler? SessionMigrationHandler { get; set; } /// @@ -144,6 +200,7 @@ public class HttpServerTransportOptions /// Enabling a per-session can be useful for setting variables /// that persist for the entire session, but it prevents you from using IHttpContextAccessor in handlers. /// + [Obsolete(Obsoletions.LegacyStatefulHttp_Message, DiagnosticId = Obsoletions.LegacyStatefulHttp_DiagnosticId, UrlFormat = Obsoletions.LegacyStatefulHttp_Url)] public bool PerSessionExecutionContext { get; set; } /// @@ -162,6 +219,7 @@ public class HttpServerTransportOptions /// tied to the open GET /sse request, and they are removed immediately when the client disconnects. /// /// + [Obsolete(Obsoletions.LegacyStatefulHttp_Message, DiagnosticId = Obsoletions.LegacyStatefulHttp_DiagnosticId, UrlFormat = Obsoletions.LegacyStatefulHttp_Url)] public TimeSpan IdleTimeout { get; set; } = TimeSpan.FromHours(2); /// @@ -182,6 +240,7 @@ public class HttpServerTransportOptions /// exactly as long as the SSE connection is open. /// /// + [Obsolete(Obsoletions.LegacyStatefulHttp_Message, DiagnosticId = Obsoletions.LegacyStatefulHttp_DiagnosticId, UrlFormat = Obsoletions.LegacyStatefulHttp_Url)] public int MaxIdleSessionCount { get; set; } = 10_000; /// diff --git a/src/ModelContextProtocol.AspNetCore/HttpServerTransportOptionsSetup.cs b/src/ModelContextProtocol.AspNetCore/HttpServerTransportOptionsSetup.cs index b4ce545f8..b5fad97a7 100644 --- a/src/ModelContextProtocol.AspNetCore/HttpServerTransportOptionsSetup.cs +++ b/src/ModelContextProtocol.AspNetCore/HttpServerTransportOptionsSetup.cs @@ -12,7 +12,9 @@ internal sealed class HttpServerTransportOptionsSetup(IServiceProvider servicePr { public void Configure(HttpServerTransportOptions options) { +#pragma warning disable MCP9006 // Stateful Streamable HTTP options are obsolete but still wired up internally. options.EventStreamStore ??= serviceProvider.GetService(); options.SessionMigrationHandler ??= serviceProvider.GetService(); +#pragma warning restore MCP9006 } } diff --git a/src/ModelContextProtocol.AspNetCore/IdleTrackingBackgroundService.cs b/src/ModelContextProtocol.AspNetCore/IdleTrackingBackgroundService.cs index d68f83e5d..de11d8a2a 100644 --- a/src/ModelContextProtocol.AspNetCore/IdleTrackingBackgroundService.cs +++ b/src/ModelContextProtocol.AspNetCore/IdleTrackingBackgroundService.cs @@ -1,4 +1,4 @@ -using Microsoft.Extensions.Hosting; +using Microsoft.Extensions.Hosting; using Microsoft.Extensions.Logging; using Microsoft.Extensions.Options; @@ -18,12 +18,14 @@ public IdleTrackingBackgroundService( ILogger logger) { // Still run loop given infinite IdleTimeout to enforce the MaxIdleSessionCount and assist graceful shutdown. +#pragma warning disable MCP9006 // Stateful Streamable HTTP options are obsolete but still wired up internally. if (options.Value.IdleTimeout != Timeout.InfiniteTimeSpan) { ArgumentOutOfRangeException.ThrowIfLessThan(options.Value.IdleTimeout, TimeSpan.Zero); } ArgumentOutOfRangeException.ThrowIfLessThan(options.Value.MaxIdleSessionCount, 0); +#pragma warning restore MCP9006 _sessions = sessions; _options = options; @@ -31,6 +33,17 @@ public IdleTrackingBackgroundService( _logger = logger; } + public override Task StartAsync(CancellationToken cancellationToken) + { + // In stateless mode there are no sessions to track, so skip starting the periodic timer entirely. + if (_options.Value.SessionMode is HttpServerSessionMode.Stateless) + { + return Task.CompletedTask; + } + + return base.StartAsync(cancellationToken); + } + protected override async Task ExecuteAsync(CancellationToken stoppingToken) { try diff --git a/src/ModelContextProtocol.AspNetCore/McpEndpointRouteBuilderExtensions.cs b/src/ModelContextProtocol.AspNetCore/McpEndpointRouteBuilderExtensions.cs index c95a5a835..e5fc3fa4d 100644 --- a/src/ModelContextProtocol.AspNetCore/McpEndpointRouteBuilderExtensions.cs +++ b/src/ModelContextProtocol.AspNetCore/McpEndpointRouteBuilderExtensions.cs @@ -32,7 +32,7 @@ public static IEndpointConventionBuilder MapMcp(this IEndpointRouteBuilder endpo var options = streamableHttpHandler.HttpServerTransportOptions; #pragma warning disable MCP9004 // EnableLegacySse - reading the obsolete property to check if SSE is enabled - if (options.Stateless && options.EnableLegacySse) + if (options.SessionMode is HttpServerSessionMode.Stateless && options.EnableLegacySse) { throw new InvalidOperationException( "Legacy SSE endpoints cannot be enabled in stateless mode because SSE requires in-memory session state " + @@ -50,10 +50,12 @@ public static IEndpointConventionBuilder MapMcp(this IEndpointRouteBuilder endpo .WithMetadata(new ProducesResponseTypeMetadata(StatusCodes.Status200OK, contentTypes: ["text/event-stream"])) .WithMetadata(new ProducesResponseTypeMetadata(StatusCodes.Status202Accepted)); - if (!options.Stateless) + if (options.SessionMode is not HttpServerSessionMode.Stateless) { // The GET endpoint is not mapped in Stateless mode since there's no way to send unsolicited messages. // Resuming streams via GET is currently not supported in Stateless mode. + // In StatefulForInitializeClients mode both endpoints stay mapped for initialize-handshake clients; + // the handlers reject 2026-07-28 and later requests with 405 Method Not Allowed. streamableHttpGroup.MapGet("", streamableHttpHandler.HandleGetRequestAsync) .WithMetadata(new ProducesResponseTypeMetadata(StatusCodes.Status200OK, contentTypes: ["text/event-stream"])); diff --git a/src/ModelContextProtocol.AspNetCore/ModelContextProtocol.AspNetCore.csproj b/src/ModelContextProtocol.AspNetCore/ModelContextProtocol.AspNetCore.csproj index 980cd1a40..4c46acdd1 100644 --- a/src/ModelContextProtocol.AspNetCore/ModelContextProtocol.AspNetCore.csproj +++ b/src/ModelContextProtocol.AspNetCore/ModelContextProtocol.AspNetCore.csproj @@ -10,6 +10,7 @@ ASP.NET Core extensions for the C# Model Context Protocol (MCP) SDK. README.md true + $(NoWarn);MCPEXP001 @@ -23,6 +24,8 @@ + + diff --git a/src/ModelContextProtocol.AspNetCore/SseEventStreamReaderExtensions.cs b/src/ModelContextProtocol.AspNetCore/SseEventStreamReaderExtensions.cs index 7c6970c70..f17df37a1 100644 --- a/src/ModelContextProtocol.AspNetCore/SseEventStreamReaderExtensions.cs +++ b/src/ModelContextProtocol.AspNetCore/SseEventStreamReaderExtensions.cs @@ -7,6 +7,8 @@ namespace ModelContextProtocol.AspNetCore; +#pragma warning disable MCP9006 // These extensions only operate on the obsolete legacy resumability reader. + /// /// Provides extension methods for . /// diff --git a/src/ModelContextProtocol.AspNetCore/StatefulSessionManager.cs b/src/ModelContextProtocol.AspNetCore/StatefulSessionManager.cs index 880bd04a5..06573ec9f 100644 --- a/src/ModelContextProtocol.AspNetCore/StatefulSessionManager.cs +++ b/src/ModelContextProtocol.AspNetCore/StatefulSessionManager.cs @@ -1,4 +1,4 @@ -using System.Collections.Concurrent; +using System.Collections.Concurrent; using System.Diagnostics; using System.Diagnostics.CodeAnalysis; using System.Runtime.InteropServices; @@ -17,9 +17,11 @@ internal sealed partial class StatefulSessionManager( private readonly ConcurrentDictionary _sessions = new(StringComparer.Ordinal); private readonly TimeProvider _timeProvider = httpServerTransportOptions.Value.TimeProvider; +#pragma warning disable MCP9006 // Stateful Streamable HTTP options are obsolete but still wired up internally. private readonly TimeSpan _idleTimeout = httpServerTransportOptions.Value.IdleTimeout; private readonly long _idleTimeoutTicks = GetIdleTimeoutInTimestampTicks(httpServerTransportOptions.Value.IdleTimeout, httpServerTransportOptions.Value.TimeProvider); private readonly int _maxIdleSessionCount = httpServerTransportOptions.Value.MaxIdleSessionCount; +#pragma warning restore MCP9006 private readonly object _idlePruningLock = new(); private readonly List _idleTimestamps = []; diff --git a/src/ModelContextProtocol.AspNetCore/StreamableHttpHandler.cs b/src/ModelContextProtocol.AspNetCore/StreamableHttpHandler.cs index ec28eff84..50c20a792 100644 --- a/src/ModelContextProtocol.AspNetCore/StreamableHttpHandler.cs +++ b/src/ModelContextProtocol.AspNetCore/StreamableHttpHandler.cs @@ -1,4 +1,5 @@ -using Microsoft.AspNetCore.Http; +using System.Buffers; +using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Http.Features; using Microsoft.AspNetCore.WebUtilities; using Microsoft.Extensions.Hosting; @@ -8,8 +9,11 @@ using ModelContextProtocol.Protocol; using ModelContextProtocol.Server; using System.Collections.Concurrent; +using System.Diagnostics.CodeAnalysis; using System.Security.Claims; using System.Security.Cryptography; +using System.Text.Json; +using System.Text.Json.Nodes; using System.Text.Json.Serialization.Metadata; namespace ModelContextProtocol.AspNetCore; @@ -23,21 +27,21 @@ internal sealed class StreamableHttpHandler( IServiceProvider applicationServices, ILoggerFactory loggerFactory) { - private const string McpSessionIdHeaderName = "Mcp-Session-Id"; - private const string McpProtocolVersionHeaderName = "MCP-Protocol-Version"; - private const string LastEventIdHeaderName = "Last-Event-ID"; + private const string McpSessionIdHeaderName = McpHttpHeaders.SessionId; + private const string McpProtocolVersionHeaderName = McpHttpHeaders.ProtocolVersion; + private const string LastEventIdHeaderName = McpHttpHeaders.LastEventId; /// /// All protocol versions supported by this implementation. - /// Keep in sync with McpSessionHandler.SupportedProtocolVersions in ModelContextProtocol.Core. /// - private static readonly HashSet s_supportedProtocolVersions = - [ - "2024-11-05", - "2025-03-26", - "2025-06-18", - "2025-11-25", - ]; + private static readonly string[] s_supportedProtocolVersions = McpProtocolVersions.SupportedProtocolVersions; + + /// + /// The supported protocol versions that still allow Streamable HTTP sessions (excluding 2026-07-28 and + /// later). Used when refusing a 2026-07-28 request on a fully stateful server so a dual-path client falls + /// back to the initialize handshake instead of retrying the 2026-07-28 version. + /// + private static readonly string[] s_sessionSupportingProtocolVersions = McpProtocolVersions.InitializeHandshakeProtocolVersions; private static readonly JsonTypeInfo s_messageTypeInfo = GetRequiredJsonTypeInfo(); private static readonly JsonTypeInfo s_errorTypeInfo = GetRequiredJsonTypeInfo(); @@ -49,14 +53,16 @@ internal sealed class StreamableHttpHandler( public HttpServerTransportOptions HttpServerTransportOptions => httpServerTransportOptions.Value; + /// + /// Returns when no request served by this endpoint can have a session. In + /// mode this is + /// even though individual 2026-07-28 and later requests are still served statelessly, because the + /// endpoint as a whole still tracks sessions for initialize-handshake clients. + /// + private bool IsStatelessOnly => HttpServerTransportOptions.SessionMode is HttpServerSessionMode.Stateless; + public async Task HandlePostRequestAsync(HttpContext context) { - if (!ValidateProtocolVersionHeader(context, out var errorMessage)) - { - await WriteJsonRpcErrorAsync(context, errorMessage!, StatusCodes.Status400BadRequest); - return; - } - // The Streamable HTTP spec mandates the client MUST accept both application/json and text/event-stream. // ASP.NET Core Minimal APIs mostly try to stay out of the business of response content negotiation, // so we have to do this manually. The spec doesn't mandate that servers MUST reject these requests, @@ -70,16 +76,84 @@ await WriteJsonRpcErrorAsync(context, return; } - var message = await ReadJsonRpcMessageAsync(context); + JsonRpcMessage? message; + try + { + message = await ReadJsonRpcMessageAsync(context); + } + catch (JsonException) + { + // The POST body was not a well-formed JSON-RPC message (malformed JSON, or a request whose + // id was explicitly null, which MCP forbids). Surface a conformant JSON-RPC error response + // with a null id rather than letting the exception bubble up as an opaque 500. + await WriteJsonRpcErrorAsync(context, + "Bad Request: The POST body did not contain a valid JSON-RPC message.", + StatusCodes.Status400BadRequest, (int)McpErrorCode.InvalidRequest); + return; + } + if (message is null) { await WriteJsonRpcErrorAsync(context, "Bad Request: The POST body did not contain a valid JSON-RPC message.", - StatusCodes.Status400BadRequest); + StatusCodes.Status400BadRequest, (int)McpErrorCode.InvalidRequest); return; } - var session = await GetOrCreateSessionAsync(context, message); + // Once the body has been parsed into a request with a readable id, every JSON-RPC error response + // for this request MUST echo that id (base protocol responses section; SEP-2243 error format). + // Notifications carry no id, so this stays default (null), which is correct. + var requestId = message is JsonRpcRequest jsonRpcRequest ? jsonRpcRequest.Id : default; + + // Validated after the body parse (rather than first) so the rejection can echo the request's + // JSON-RPC id: every error response for a parseable request MUST carry its id. + var configuredSupportedProtocolVersions = GetConfiguredSupportedProtocolVersions(mcpServerOptionsSnapshot.Value.ProtocolVersion); + if (!ValidateProtocolVersionHeader(context, configuredSupportedProtocolVersions, IsStatelessOnly, out var protocolVersionError)) + { + await WriteJsonRpcErrorDetailAsync(context, protocolVersionError, StatusCodes.Status400BadRequest, requestId); + return; + } + + if (!ValidateProtocolVersionEnvelope(context, message, out var protocolVersionEnvelopeError)) + { + await WriteJsonRpcErrorDetailAsync(context, protocolVersionEnvelopeError, StatusCodes.Status400BadRequest, requestId); + return; + } + + if (!ValidateMcpHeaders(context, message, mcpServerOptionsSnapshot.Value, out var errorMessage)) + { + await WriteJsonRpcErrorAsync(context, errorMessage, StatusCodes.Status400BadRequest, (int)McpErrorCode.HeaderMismatch, requestId); + return; + } + + if (!ValidateRequiredPerRequestMeta(context, message, out var requiredMetaError)) + { + await WriteJsonRpcErrorDetailAsync(context, requiredMetaError, StatusCodes.Status400BadRequest, requestId); + return; + } + + // SEP-2575 removed these RPCs from the per-request-metadata HTTP surface (initialize and + // ping in favor of server/discover, logging/setLevel in favor of _meta logLevel, and the + // resource subscription pair in favor of subscriptions/listen). A request for a method the + // server does not implement is rejected with 404 Not Found and Method not found. Rejecting + // here gives HTTP the required status; the server protocol boundary enforces the same method + // set for other transports. +#pragma warning disable MCP9005 // logging/setLevel is deprecated (SEP-2577); referenced here only to reject it as removed. + if (RequiresPerRequestMetadataProtocol(context) && + message is JsonRpcRequest + { + Method: RequestMethods.Initialize or RequestMethods.Ping or RequestMethods.LoggingSetLevel + or RequestMethods.ResourcesSubscribe or RequestMethods.ResourcesUnsubscribe, + } removedMethodRequest) +#pragma warning restore MCP9005 + { + await WriteJsonRpcErrorAsync(context, + $"Method '{removedMethodRequest.Method}' is not available on protocol version '{context.Request.Headers[McpProtocolVersionHeaderName]}'.", + StatusCodes.Status404NotFound, (int)McpErrorCode.MethodNotFound, requestId); + return; + } + + var session = await GetOrCreateSessionAsync(context, message, requestId); if (session is null) { return; @@ -87,8 +161,33 @@ await WriteJsonRpcErrorAsync(context, await using var _ = await session.AcquireReferenceAsync(context.RequestAborted); + Func? onResponseStarting = null; + if (RequiresPerRequestMetadataProtocol(context)) + { + // SEP-2575 maps some JSON-RPC error codes onto HTTP statuses (404 for a method the server + // does not implement, 400 for missing-capability and unsupported-version rejections). The + // status line can only be chosen before the first response byte, so the transport defers + // its eager header flush and reports the first response message here. + onResponseStarting = firstMessage => + { + if (firstMessage is JsonRpcError { Error: { } errorDetail } && !context.Response.HasStarted) + { + context.Response.StatusCode = (McpErrorCode)errorDetail.Code switch + { + McpErrorCode.MethodNotFound => StatusCodes.Status404NotFound, + McpErrorCode.MissingRequiredClientCapability => StatusCodes.Status400BadRequest, + McpErrorCode.UnsupportedProtocolVersion => StatusCodes.Status400BadRequest, + McpErrorCode.HeaderMismatch => StatusCodes.Status400BadRequest, + _ => context.Response.StatusCode, + }; + } + + return default; + }; + } + InitializeSseResponse(context); - var wroteResponse = await session.Transport.HandlePostRequestAsync(message, context.Response.Body, context.RequestAborted); + var wroteResponse = await session.Transport.HandlePostRequestAsync(message, context.Response.Body, onResponseStarting, context.RequestAborted); if (!wroteResponse) { // We wound up writing nothing, so there should be no Content-Type response header. @@ -99,9 +198,24 @@ await WriteJsonRpcErrorAsync(context, public async Task HandleGetRequestAsync(HttpContext context) { - if (!ValidateProtocolVersionHeader(context, out var errorMessage)) + var configuredSupportedProtocolVersions = GetConfiguredSupportedProtocolVersions(mcpServerOptionsSnapshot.Value.ProtocolVersion); + if (!ValidateProtocolVersionHeader(context, configuredSupportedProtocolVersions, IsStatelessOnly, out var protocolVersionError)) + { + await WriteJsonRpcErrorDetailAsync(context, protocolVersionError, StatusCodes.Status400BadRequest); + return; + } + + var sessionId = context.Request.Headers[McpSessionIdHeaderName].ToString(); + + // The 2026-07-28 revision (SEP-2575) removes the standalone HTTP GET endpoint for unsolicited + // server-to-client messages; clients use subscriptions/listen (POST) instead. Because Streamable HTTP + // no longer has sessions (SEP-2567), the GET is invalid whether or not it carries an Mcp-Session-Id. + if (RequiresPerRequestMetadataProtocol(context)) { - await WriteJsonRpcErrorAsync(context, errorMessage!, StatusCodes.Status400BadRequest); + context.Response.Headers.Allow = HttpMethods.Post; + await WriteJsonRpcErrorAsync(context, + "Method Not Allowed: The GET endpoint is not supported by the 2026-07-28 and later protocol revisions. Use subscriptions/listen via POST instead.", + StatusCodes.Status405MethodNotAllowed); return; } @@ -113,7 +227,6 @@ await WriteJsonRpcErrorAsync(context, return; } - var sessionId = context.Request.Headers[McpSessionIdHeaderName].ToString(); var session = await GetSessionAsync(context, sessionId); if (session is null) { @@ -133,7 +246,7 @@ await WriteJsonRpcErrorAsync(context, private async Task HandleResumedStreamAsync(HttpContext context, StreamableHttpSession session, string lastEventId) { - if (HttpServerTransportOptions.Stateless) + if (IsStatelessOnly) { await WriteJsonRpcErrorAsync(context, "Bad Request: The Last-Event-ID header is not supported in stateless mode.", @@ -194,7 +307,9 @@ await WriteJsonRpcErrorAsync(context, } } +#pragma warning disable MCP9006 // Stateful Streamable HTTP resumability types are obsolete but still wired up internally. private static async Task HandleResumePostResponseStreamAsync(HttpContext context, ISseEventStreamReader eventStreamReader) +#pragma warning restore MCP9006 { InitializeSseResponse(context); await eventStreamReader.CopyToAsync(context.Response.Body, context.RequestAborted); @@ -202,28 +317,54 @@ private static async Task HandleResumePostResponseStreamAsync(HttpContext contex public async Task HandleDeleteRequestAsync(HttpContext context) { - if (!ValidateProtocolVersionHeader(context, out var errorMessage)) + var configuredSupportedProtocolVersions = GetConfiguredSupportedProtocolVersions(mcpServerOptionsSnapshot.Value.ProtocolVersion); + if (!ValidateProtocolVersionHeader(context, configuredSupportedProtocolVersions, IsStatelessOnly, out var protocolVersionError)) { - await WriteJsonRpcErrorAsync(context, errorMessage!, StatusCodes.Status400BadRequest); + await WriteJsonRpcErrorDetailAsync(context, protocolVersionError, StatusCodes.Status400BadRequest); return; } var sessionId = context.Request.Headers[McpSessionIdHeaderName].ToString(); - if (sessionManager.TryRemove(sessionId, out var session)) + + // Starting with the 2026-07-28 revision, Streamable HTTP has no sessions to terminate (SEP-2567), + // so the DELETE is invalid whether or not it carries an Mcp-Session-Id. + if (RequiresPerRequestMetadataProtocol(context)) + { + context.Response.Headers.Allow = HttpMethods.Post; + await WriteJsonRpcErrorAsync(context, + "Method Not Allowed: The DELETE endpoint is not supported by the 2026-07-28 and later protocol revisions.", + StatusCodes.Status405MethodNotAllowed); + return; + } + + if (string.IsNullOrEmpty(sessionId) || !sessionManager.TryGetValue(sessionId, out var session)) + { + return; + } + + if (!session.HasSameUserId(context.User)) + { + await WriteJsonRpcErrorAsync(context, + "Forbidden: The currently authenticated user does not match the user who initiated the session.", + StatusCodes.Status403Forbidden); + return; + } + + if (sessionManager.TryRemove(sessionId, out session)) { await session.DisposeAsync(); } } - private async ValueTask GetSessionAsync(HttpContext context, string sessionId) + private async ValueTask GetSessionAsync(HttpContext context, string sessionId, RequestId requestId = default) { if (string.IsNullOrEmpty(sessionId)) { await WriteJsonRpcErrorAsync(context, "Bad Request: Mcp-Session-Id header is required for GET and DELETE requests when the server is using sessions. " + - "If your server doesn't need sessions, enable stateless mode by setting HttpServerTransportOptions.Stateless = true. " + + "If your server doesn't need sessions, enable stateless mode by setting HttpServerTransportOptions.SessionMode = HttpServerSessionMode.Stateless. " + "See https://csharp.sdk.modelcontextprotocol.io/concepts/stateless/stateless.html for more details.", - StatusCodes.Status400BadRequest); + StatusCodes.Status400BadRequest, requestId: requestId); return null; } @@ -238,7 +379,7 @@ await WriteJsonRpcErrorAsync(context, // One of the few other usages I found was from some Ethereum JSON-RPC documentation and this // JSON-RPC library from Microsoft called StreamJsonRpc where it's called JsonRpcErrorCode.NoMarshaledObjectFound // https://learn.microsoft.com/dotnet/api/streamjsonrpc.protocol.jsonrpcerrorcode?view=streamjsonrpc-2.9#fields - await WriteJsonRpcErrorAsync(context, "Session not found", StatusCodes.Status404NotFound, -32001); + await WriteJsonRpcErrorAsync(context, "Session not found", StatusCodes.Status404NotFound, -32001, requestId); return null; } } @@ -247,7 +388,7 @@ await WriteJsonRpcErrorAsync(context, { await WriteJsonRpcErrorAsync(context, "Forbidden: The currently authenticated user does not match the user who initiated the session.", - StatusCodes.Status403Forbidden); + StatusCodes.Status403Forbidden, requestId: requestId); return null; } @@ -258,10 +399,12 @@ await WriteJsonRpcErrorAsync(context, private async ValueTask TryMigrateSessionAsync(HttpContext context, string sessionId) { +#pragma warning disable MCP9006 // Stateful Streamable HTTP options are obsolete but still wired up internally. if (HttpServerTransportOptions.SessionMigrationHandler is not { } handler) { return null; } +#pragma warning restore MCP9006 var migrationLock = _migrationLocks.GetOrAdd(sessionId, static _ => new SemaphoreSlim(1, 1)); await migrationLock.WaitAsync(context.RequestAborted); @@ -294,48 +437,78 @@ await WriteJsonRpcErrorAsync(context, } } - private async ValueTask GetOrCreateSessionAsync(HttpContext context, JsonRpcMessage message) + private async ValueTask GetOrCreateSessionAsync(HttpContext context, JsonRpcMessage message, RequestId requestId = default) { - var sessionId = context.Request.Headers[McpSessionIdHeaderName].ToString(); + // The 2026-07-28 revision removes the Mcp-Session-Id header and the session concept (SEP-2567) + // and the initialize handshake (SEP-2575), so over HTTP it never has a session, with no exceptions: + if (RequiresPerRequestMetadataProtocol(context)) + { + if (HttpServerTransportOptions.SessionMode is HttpServerSessionMode.Stateful) + { + // The author explicitly opted into sessions for every client, which the 2026-07-28 revision + // cannot provide. Refuse it so a dual-path client falls back to the initialize handshake and + // gets the session it asked for (SEP-2575 fallback semantics). StatefulForInitializeClients + // opts out of that downgrade and serves these requests statelessly instead. + await WriteUnsupportedProtocolVersionErrorAsync(context, requestId); + return null; + } + + // Stateless and StatefulForInitializeClients both serve these requests natively, without a session. + return await StartNewSessionAsync(context, serveStatelessly: true); + } + var sessionId = context.Request.Headers[McpSessionIdHeaderName].ToString(); if (string.IsNullOrEmpty(sessionId)) { // In stateful mode, only allow creating new sessions for initialize requests. // In stateless mode, every request is independent, so we always create a new session. - if (!HttpServerTransportOptions.Stateless && !AllowNewSessionForNonInitializeRequests + if (!IsStatelessOnly && !AllowNewSessionForNonInitializeRequests && message is not JsonRpcRequest { Method: RequestMethods.Initialize }) { await WriteJsonRpcErrorAsync(context, "Bad Request: A new session can only be created by an initialize request. Include a valid Mcp-Session-Id header for non-initialize requests, " + - "or enable stateless mode by setting HttpServerTransportOptions.Stateless = true if your server doesn't need sessions. " + + "or enable stateless mode by setting HttpServerTransportOptions.SessionMode = HttpServerSessionMode.Stateless if your server doesn't need sessions. " + "See https://csharp.sdk.modelcontextprotocol.io/concepts/stateless/stateless.html for more details.", - StatusCodes.Status400BadRequest); + StatusCodes.Status400BadRequest, requestId: requestId); return null; } - return await StartNewSessionAsync(context); + return await StartNewSessionAsync(context, serveStatelessly: IsStatelessOnly); } - else if (HttpServerTransportOptions.Stateless) + else if (IsStatelessOnly) { // In stateless mode, we should not be getting existing sessions via sessionId // This path should not be reached in stateless mode - await WriteJsonRpcErrorAsync(context, "Bad Request: The Mcp-Session-Id header is not supported in stateless mode", StatusCodes.Status400BadRequest); + await WriteJsonRpcErrorAsync(context, "Bad Request: The Mcp-Session-Id header is not supported in stateless mode", StatusCodes.Status400BadRequest, requestId: requestId); return null; } else { - return await GetSessionAsync(context, sessionId); + return await GetSessionAsync(context, sessionId, requestId); } } - private async ValueTask StartNewSessionAsync(HttpContext context) + /// + /// Returns when the request's MCP-Protocol-Version header declares a + /// revision that operates without sessions, so the server must serve it statelessly. Such requests + /// do not use an Mcp-Session-Id and never perform the initialize handshake + /// (SEP-2575 + SEP-2567). + /// + private static bool RequiresPerRequestMetadataProtocol(HttpContext context) + { + var protocolVersionHeader = context.Request.Headers[McpProtocolVersionHeaderName].ToString(); + return McpProtocolVersions.RequiresPerRequestMetadata(protocolVersionHeader); + } + + private async ValueTask StartNewSessionAsync(HttpContext context, bool serveStatelessly) { string sessionId; StreamableHttpServerTransport transport; - if (!HttpServerTransportOptions.Stateless) + if (!serveStatelessly) { sessionId = MakeNewSessionId(); +#pragma warning disable MCP9006 // Stateful Streamable HTTP options are obsolete but still wired up internally. transport = new(loggerFactory) { SessionId = sessionId, @@ -345,6 +518,7 @@ private async ValueTask StartNewSessionAsync(HttpContext ? (initParams, ct) => handler.OnSessionInitializedAsync(context, sessionId, initParams, ct) : null, }; +#pragma warning restore MCP9006 context.Response.Headers[McpSessionIdHeaderName] = sessionId; } @@ -360,22 +534,24 @@ private async ValueTask StartNewSessionAsync(HttpContext }; } - return await CreateSessionAsync(context, transport, sessionId); + return await CreateSessionAsync(context, transport, sessionId, serveStatelessly); } private async ValueTask CreateSessionAsync( HttpContext context, StreamableHttpServerTransport transport, string sessionId, + bool serveStatelessly, Action? configureOptions = null) { var mcpServerServices = applicationServices; var mcpServerOptions = mcpServerOptionsSnapshot.Value; - if (HttpServerTransportOptions.Stateless || HttpServerTransportOptions.ConfigureSessionOptions is not null || configureOptions is not null) + + if (serveStatelessly || HttpServerTransportOptions.ConfigureSessionOptions is not null || configureOptions is not null) { mcpServerOptions = mcpServerOptionsFactory.Create(Options.DefaultName); - if (HttpServerTransportOptions.Stateless) + if (serveStatelessly) { // The session does not outlive the request in stateless mode. mcpServerServices = context.RequestServices; @@ -412,8 +588,10 @@ private async ValueTask MigrateSessionAsync( var transport = new StreamableHttpServerTransport(loggerFactory) { SessionId = sessionId, +#pragma warning disable MCP9006 // Stateful Streamable HTTP options are obsolete but still wired up internally. FlowExecutionContextFromRequests = !HttpServerTransportOptions.PerSessionExecutionContext, EventStreamStore = HttpServerTransportOptions.EventStreamStore, +#pragma warning restore MCP9006 }; // Initialize the transport with the migrated session's init params. @@ -421,16 +599,18 @@ private async ValueTask MigrateSessionAsync( context.Response.Headers[McpSessionIdHeaderName] = sessionId; - return await CreateSessionAsync(context, transport, sessionId, options => + return await CreateSessionAsync(context, transport, sessionId, serveStatelessly: false, options => { options.KnownClientInfo = initializeParams.ClientInfo; options.KnownClientCapabilities = initializeParams.Capabilities; }); } +#pragma warning disable MCP9006 // Stateful Streamable HTTP resumability types are obsolete but still wired up internally. private async ValueTask GetEventStreamReaderAsync(HttpContext context, string lastEventId) { if (HttpServerTransportOptions.EventStreamStore is not { } eventStreamStore) +#pragma warning restore MCP9006 { await WriteJsonRpcErrorAsync(context, "Bad Request: This server does not support resuming streams.", @@ -450,10 +630,11 @@ await WriteJsonRpcErrorAsync(context, return eventStreamReader; } - private static Task WriteJsonRpcErrorAsync(HttpContext context, string errorMessage, int statusCode, int errorCode = -32000) + private static Task WriteJsonRpcErrorAsync(HttpContext context, string errorMessage, int statusCode, int errorCode = -32000, RequestId requestId = default) { var jsonRpcError = new JsonRpcError { + Id = requestId, Error = new() { Code = errorCode, @@ -486,12 +667,25 @@ internal static string MakeNewSessionId() // Implementation for reading a JSON-RPC message from the request body var message = await context.Request.ReadFromJsonAsync(s_messageTypeInfo, context.RequestAborted); - if (context.User?.Identity?.IsAuthenticated == true && message is not null) + if (message is not null) { - message.Context = new() + var protocolVersion = context.Request.Headers[McpProtocolVersionHeaderName].ToString(); + var isAuthenticated = context.User?.Identity?.IsAuthenticated == true; + + if (isAuthenticated || !string.IsNullOrEmpty(protocolVersion)) { - User = context.User, - }; + message.Context ??= new(); + + if (isAuthenticated) + { + message.Context.User = context.User; + } + + if (!string.IsNullOrEmpty(protocolVersion)) + { + message.Context.ProtocolVersion = protocolVersion; + } + } } return message; @@ -522,17 +716,347 @@ internal static Task RunSessionAsync(HttpContext httpContext, McpServer session, internal static JsonTypeInfo GetRequiredJsonTypeInfo() => (JsonTypeInfo)McpJsonUtilities.DefaultOptions.GetTypeInfo(typeof(T)); + /// + /// Validates that a request riding a per-request-metadata protocol revision carries the required + /// _meta fields beyond the protocol version (which + /// already checked): io.modelcontextprotocol/clientCapabilities, which must be present and a + /// JSON object. Performed at the HTTP layer so the rejection can use 400 Bad Request as SEP-2575 + /// requires; a malformed (non-object) value would otherwise fail later during deserialization as a + /// generic internal error on a 200 response. clientInfo is optional, so its absence is not + /// rejected. + /// + private static bool ValidateRequiredPerRequestMeta( + HttpContext context, + JsonRpcMessage message, + [NotNullWhen(false)] out JsonRpcErrorDetail? errorDetail) + { + var protocolVersionHeader = context.Request.Headers[McpProtocolVersionHeaderName].ToString(); + if (message is JsonRpcRequest { Params: var requestParams } && + McpProtocolVersions.RequiresPerRequestMetadata(protocolVersionHeader) && + (requestParams is not JsonObject paramsObj || + paramsObj["_meta"] is not JsonObject metaObj || + metaObj[MetaKeys.ClientCapabilities] is not JsonObject)) + { + errorDetail = new JsonRpcErrorDetail + { + Code = (int)McpErrorCode.InvalidParams, + Message = $"Requests using protocol version '{protocolVersionHeader}' must include '_meta/{MetaKeys.ClientCapabilities}' as a JSON object.", + }; + return false; + } + + errorDetail = null; + return true; + } + /// /// Validates the MCP-Protocol-Version header if present. A missing header is allowed for backwards compatibility, - /// but an invalid or unsupported value must be rejected with 400 Bad Request per the MCP spec. + /// but an invalid or unsupported value must be rejected with 400 Bad Request per the MCP spec. Per SEP-2575, the + /// rejection uses the error code with a data payload + /// listing the server's supported versions so the client can select a fallback. /// - private static bool ValidateProtocolVersionHeader(HttpContext context, out string? errorMessage) + private static bool ValidateProtocolVersionHeader( + HttpContext context, + IReadOnlyList supportedProtocolVersions, + bool stateless, + [NotNullWhen(false)] out JsonRpcErrorDetail? errorDetail) { var protocolVersionHeader = context.Request.Headers[McpProtocolVersionHeaderName].ToString(); if (!string.IsNullOrEmpty(protocolVersionHeader) && - !s_supportedProtocolVersions.Contains(protocolVersionHeader)) + !supportedProtocolVersions.Contains(protocolVersionHeader)) + { + // On a stateless server, restrict the advertised list to the per-request-metadata + // revisions: those are what server/discover advertises, and SEP-2575 clients use this + // list to pick a retry version for server/discover, so the two must agree. Requests for + // the older initialize-handshake revisions are still accepted above; only the error + // payload for unknown versions narrows. Stateful servers keep the full configured list + // (their 2026-07-28 refusal advertises the session-supporting versions separately in + // WriteUnsupportedProtocolVersionErrorAsync). + IReadOnlyList advertisedVersions = supportedProtocolVersions; + if (stateless) + { + var metadataVersions = supportedProtocolVersions.Where(McpProtocolVersions.RequiresPerRequestMetadata).ToArray(); + if (metadataVersions.Length > 0) + { + advertisedVersions = metadataVersions; + } + } + + errorDetail = new JsonRpcErrorDetail + { + Code = (int)McpErrorCode.UnsupportedProtocolVersion, + Message = $"Bad Request: The MCP-Protocol-Version header value '{protocolVersionHeader}' is not supported.", + Data = JsonSerializer.SerializeToNode( + new UnsupportedProtocolVersionErrorData + { + Supported = [.. advertisedVersions], + Requested = protocolVersionHeader, + }, + GetRequiredJsonTypeInfo()), + }; + return false; + } + + errorDetail = null; + return true; + } + + private static string[] GetConfiguredSupportedProtocolVersions(string? protocolVersion) + { + if (protocolVersion is null) + { + return s_supportedProtocolVersions; + } + + if (!McpProtocolVersions.IsSupportedProtocolVersion(protocolVersion)) + { + throw new McpException( + $"Unsupported server protocol version '{protocolVersion}'. Supported protocol versions: " + + string.Join(", ", McpProtocolVersions.SupportedProtocolVersions) + "."); + } + + return [protocolVersion]; + } + + /// + /// Validates that HTTP requests declare matching protocol versions in the + /// MCP-Protocol-Version header and the corresponding body field. + /// + private static bool ValidateProtocolVersionEnvelope( + HttpContext context, + JsonRpcMessage message, + [NotNullWhen(false)] out JsonRpcErrorDetail? errorDetail) + { + if (message is not (JsonRpcRequest or JsonRpcNotification)) + { + errorDetail = null; + return true; + } + + var protocolVersionHeader = context.Request.Headers[McpProtocolVersionHeaderName].ToString(); + + if (message is JsonRpcRequest { Method: RequestMethods.Initialize, Params: JsonObject initializeParams } && + initializeParams["protocolVersion"] is JsonValue initializeProtocolVersionValue && + initializeProtocolVersionValue.TryGetValue(out string? initializeProtocolVersion) && + !string.IsNullOrEmpty(protocolVersionHeader) && + !string.Equals(protocolVersionHeader, initializeProtocolVersion, StringComparison.Ordinal)) + { + errorDetail = CreateHeaderMismatchError( + $"Bad Request: The {McpProtocolVersionHeaderName} header value '{protocolVersionHeader}' does not match body params.protocolVersion value '{initializeProtocolVersion}'."); + return false; + } + + bool hasProtocolVersionMeta = TryGetProtocolVersionMeta(message, out var protocolVersionMeta); + + if (!McpProtocolVersions.RequiresPerRequestMetadata(protocolVersionHeader) && + !McpProtocolVersions.RequiresPerRequestMetadata(protocolVersionMeta)) + { + errorDetail = null; + return true; + } + + if (string.IsNullOrEmpty(protocolVersionHeader)) + { + errorDetail = CreateHeaderMismatchError( + $"Bad Request: The {McpProtocolVersionHeaderName} header is required when the request body declares a per-request metadata protocol version."); + return false; + } + + if (!hasProtocolVersionMeta) + { + // Notifications are exempt from the required-_meta rejection: they are fire-and-forget + // (a JSON-RPC error response has no recipient), and rejecting them silently drops + // client signals like notifications/cancelled, leaving server-side work running. + if (message is not JsonRpcRequest) + { + errorDetail = null; + return true; + } + + // A missing (rather than mismatched) per-request metadata field is an Invalid params + // rejection per SEP-2575; HeaderMismatch (-32020) is reserved for values that are + // present on both sides but disagree. + errorDetail = new JsonRpcErrorDetail + { + Code = (int)McpErrorCode.InvalidParams, + Message = $"Requests using protocol version '{protocolVersionHeader}' must include '_meta/{MetaKeys.ProtocolVersion}'.", + }; + return false; + } + + if (!string.Equals(protocolVersionHeader, protocolVersionMeta, StringComparison.Ordinal)) + { + errorDetail = CreateHeaderMismatchError( + $"Bad Request: The {McpProtocolVersionHeaderName} header value '{protocolVersionHeader}' does not match body _meta/{MetaKeys.ProtocolVersion} value '{protocolVersionMeta}'."); + return false; + } + + errorDetail = null; + return true; + } + + private static JsonRpcErrorDetail CreateHeaderMismatchError(string message) => new() + { + Code = (int)McpErrorCode.HeaderMismatch, + Message = message, + }; + + private static bool TryGetProtocolVersionMeta(JsonRpcMessage message, [NotNullWhen(true)] out string? protocolVersion) + { + var parameters = message switch + { + JsonRpcRequest request => request.Params, + JsonRpcNotification notification => notification.Params, + _ => null, + }; + + string? value = null; + if (parameters is JsonObject paramsObj && + paramsObj["_meta"] is JsonObject metaObj && + metaObj[MetaKeys.ProtocolVersion] is JsonValue protocolVersionValue && + protocolVersionValue.TryGetValue(out value) && + !string.IsNullOrEmpty(value)) + { + protocolVersion = value; + return true; + } + + protocolVersion = null; + return false; + } + + /// + /// Refuses a 2026-07-28 (or later) request on a fully stateful server + /// (). Starting with that revision, Streamable HTTP no longer + /// has sessions (SEP-2567), so it cannot honor the author's opt-in to sessions; we return + /// with a supported-versions list that excludes + /// 2026-07-28 and later. A dual-path client then falls back to the initialize handshake (SEP-2575). + /// serves the request statelessly instead + /// of refusing it. + /// + private static Task WriteUnsupportedProtocolVersionErrorAsync(HttpContext context, RequestId requestId = default) + { + var requestedProtocolVersion = context.Request.Headers[McpProtocolVersionHeaderName].ToString(); + var errorDetail = new JsonRpcErrorDetail + { + Code = (int)McpErrorCode.UnsupportedProtocolVersion, + Message = $"Bad Request: Starting with protocol version '{McpProtocolVersions.July2026ProtocolVersion}', Streamable HTTP does not support sessions and is not supported when the server is configured with sessions enabled (HttpServerTransportOptions.SessionMode = HttpServerSessionMode.Stateful). " + + "Use the initialize handshake with a protocol version that still supports sessions instead, or set HttpServerTransportOptions.SessionMode = HttpServerSessionMode.StatefulForInitializeClients to serve this version statelessly.", + Data = JsonSerializer.SerializeToNode( + new UnsupportedProtocolVersionErrorData + { + Supported = s_sessionSupportingProtocolVersions, + Requested = requestedProtocolVersion, + }, + GetRequiredJsonTypeInfo()), + }; + + return WriteJsonRpcErrorDetailAsync(context, errorDetail, StatusCodes.Status400BadRequest, requestId); + } + + /// + /// Validates standard MCP request headers (Mcp-Method, Mcp-Name) and custom parameter headers + /// (Mcp-Param-*) against the JSON-RPC request body. + /// Validation is only performed for protocol versions that include the HTTP Standardization feature. + /// + /// The HTTP context containing the request headers. + /// The JSON-RPC message to validate against. + /// The server options containing tools and custom request routing metadata. + /// Set to the error message if validation fails; null otherwise. + /// True if validation passes; false otherwise. + internal static bool ValidateMcpHeaders(HttpContext context, JsonRpcMessage message, McpServerOptions serverOptions, [NotNullWhen(false)] out string? errorMessage) + { + // Only validate for protocol versions that support standard headers. + var protocolVersion = context.Request.Headers[McpProtocolVersionHeaderName].ToString(); + if (!McpProtocolVersions.RequiresStandardHeaders(protocolVersion)) + { + errorMessage = null; + return true; + } + + // Only validate for JSON-RPC requests and notifications, not responses. + if (!(message is JsonRpcRequest || message is JsonRpcNotification)) + { + errorMessage = null; + return true; + } + + // For requests that support standard headers, the Mcp-Method header must be present + // and match the method in the JSON-RPC body. + if (!context.Request.Headers.ContainsKey(McpHttpHeaders.Method)) + { + errorMessage = "Missing required Mcp-Method header."; + return false; + } + + var mcpMethodInHeader = context.Request.Headers[McpHttpHeaders.Method].ToString().Trim(); + var mcpMethodInBody = message switch + { + JsonRpcRequest request => request.Method, + JsonRpcNotification notification => notification.Method, + _ => null, // This case is already ruled out by the earlier check, but we need it to satisfy the compiler. + }; + + if (!string.Equals(mcpMethodInHeader, mcpMethodInBody, StringComparison.Ordinal)) + { + errorMessage = $"Header mismatch: Mcp-Method header value '{mcpMethodInHeader}' does not match body value '{mcpMethodInBody}'."; + return false; + } + +#pragma warning disable MCPEXP002 + var routingNameParameter = GetRoutingNameParameter(mcpMethodInBody, serverOptions.RequestHandlers); +#pragma warning restore MCPEXP002 + if (routingNameParameter is null) + { + errorMessage = null; + return true; + } + + // For these requests, the Mcp-Name header must be present and match the name or uri in the JSON-RPC body. + if (!context.Request.Headers.ContainsKey(McpHttpHeaders.Name)) + { + errorMessage = "Missing required Mcp-Name header."; + return false; + } + + var mcpNameInHeader = context.Request.Headers[McpHttpHeaders.Name].ToString().Trim(); + + // Per SEP-2243, non-ASCII Mcp-Name values MUST be Base64-encoded using the + // "=?base64?...?=" wrapper. Reject raw values containing characters outside the valid + // HTTP header value range, then decode so the comparison below is against the + // decoded value (mirrors the Mcp-Param-* validation in ValidateCustomParamHeaders). + if (!IsValidHeaderValue(mcpNameInHeader)) + { + errorMessage = "Header mismatch: Mcp-Name header contains invalid characters."; + return false; + } + + var decodedMcpNameInHeader = McpHeaderEncoder.DecodeValue(mcpNameInHeader); + if (decodedMcpNameInHeader is null) + { + errorMessage = "Header mismatch: Mcp-Name header contains invalid Base64 encoding."; + return false; + } + + // Extract the params and name value from the body based on the method, if present. + var bodyParams = message switch + { + JsonRpcRequest request => request.Params, + JsonRpcNotification notification => notification.Params, + _ => null, + }; + var mcpNameInBody = GetJsonNodeStringProperty(bodyParams, routingNameParameter); + + // Check that the header value matches the body value if the body value is present. + if (!string.Equals(decodedMcpNameInHeader, mcpNameInBody, StringComparison.Ordinal)) + { + errorMessage = $"Header mismatch: Mcp-Name header value '{mcpNameInHeader}' does not match body value '{mcpNameInBody}'."; + return false; + } + + // Validate Mcp-Param-* custom headers against tool schema + if (!ValidateCustomParamHeaders(context, message, serverOptions.ToolCollection, out errorMessage)) { - errorMessage = $"Bad Request: The MCP-Protocol-Version header value '{protocolVersionHeader}' is not supported."; return false; } @@ -540,6 +1064,369 @@ private static bool ValidateProtocolVersionHeader(HttpContext context, out strin return true; } +#pragma warning disable MCPEXP002 + private static string? GetRoutingNameParameter( + string? method, + IList? requestHandlers) + { + var builtInParameter = method switch + { + RequestMethods.ToolsCall or RequestMethods.PromptsGet => "name", + RequestMethods.ResourcesRead => "uri", + _ => null, + }; + + if (builtInParameter is not null) + { + return builtInParameter; + } + + if (requestHandlers is not null) + { + foreach (var requestHandler in requestHandlers) + { + if (string.Equals(requestHandler.Method, method, StringComparison.Ordinal)) + { + return requestHandler.RoutingNameParameter; + } + } + } + + return null; + } +#pragma warning restore MCPEXP002 + + /// + /// Validates that all parameters annotated with x-mcp-header in the tool's input schema + /// have corresponding Mcp-Param-* headers present in the request, and that any present + /// Mcp-Param-* headers have valid encoding. + /// + private static bool ValidateCustomParamHeaders( + HttpContext context, + JsonRpcMessage message, + McpServerPrimitiveCollection? toolCollection, + [NotNullWhen(false)] out string? errorMessage) + { + // Custom param headers are only relevant for tools/call requests + if (message is not JsonRpcRequest { Method: RequestMethods.ToolsCall, Params: { } bodyParams }) + { + errorMessage = null; + return true; + } + + // Look up the tool to check for x-mcp-header annotations in the schema + var toolName = GetJsonNodeStringProperty(bodyParams, "name"); + if (toolName is null || toolCollection is null || !toolCollection.TryGetPrimitive(toolName, out var tool)) + { + errorMessage = null; + return true; + } + + var inputSchema = tool.ProtocolTool.InputSchema; + if (inputSchema.ValueKind != System.Text.Json.JsonValueKind.Object || + !inputSchema.TryGetProperty("properties", out var properties) || + properties.ValueKind != System.Text.Json.JsonValueKind.Object) + { + errorMessage = null; + return true; + } + + // Get the arguments from the body for value comparison + System.Text.Json.Nodes.JsonNode? arguments = null; + if (bodyParams is System.Text.Json.Nodes.JsonObject paramsObj) + { + paramsObj.TryGetPropertyValue("arguments", out arguments); + } + + // Check that every x-mcp-header annotated parameter has a corresponding header, + // that the header value is validly encoded, and that it matches the body value. + return ValidateCustomParamHeadersFromProperties(context, properties, arguments, out errorMessage); + } + + /// + /// Recursively validates x-mcp-header annotated properties at any nesting depth. + /// + private static bool ValidateCustomParamHeadersFromProperties( + HttpContext context, + System.Text.Json.JsonElement properties, + System.Text.Json.Nodes.JsonNode? arguments, + [NotNullWhen(false)] out string? errorMessage) + { + foreach (var property in properties.EnumerateObject()) + { + if (property.Value.ValueKind != System.Text.Json.JsonValueKind.Object) + { + continue; + } + + // Recurse into nested object properties + if (property.Value.TryGetProperty("properties", out var nestedProperties) && + nestedProperties.ValueKind == System.Text.Json.JsonValueKind.Object) + { + System.Text.Json.Nodes.JsonNode? nestedArgs = null; + if (arguments is System.Text.Json.Nodes.JsonObject parentObj) + { + parentObj.TryGetPropertyValue(property.Name, out nestedArgs); + } + + if (!ValidateCustomParamHeadersFromProperties(context, nestedProperties, nestedArgs, out errorMessage)) + { + return false; + } + } + + if (!property.Value.TryGetProperty("x-mcp-header", out var headerNameElement)) + { + continue; + } + + var headerName = headerNameElement.GetString(); + if (string.IsNullOrEmpty(headerName)) + { + continue; + } + + var fullHeaderName = $"{McpHttpHeaders.ParamPrefix}{headerName}"; + if (!context.Request.Headers.ContainsKey(fullHeaderName)) + { + // Per the SEP: if the parameter value is null or not provided in + // the arguments, the client MUST omit the header and the server + // MUST NOT expect it. Only reject when a non-null value is present + // in the body but the header is missing. + bool hasNonNullBodyValue = arguments is System.Text.Json.Nodes.JsonObject argsForMissing && + argsForMissing.TryGetPropertyValue(property.Name, out var argForMissing) && + argForMissing is not null && + argForMissing.GetValueKind() != System.Text.Json.JsonValueKind.Null; + + if (hasNonNullBodyValue) + { + errorMessage = $"Missing required {fullHeaderName} header for parameter '{property.Name}' annotated with x-mcp-header."; + return false; + } + + continue; + } + + var actualHeaderValue = context.Request.Headers[fullHeaderName].ToString().Trim(); + + // Validate the raw header value for invalid characters per SEP. + // Servers MUST reject headers containing characters outside the valid HTTP header value range. + if (!IsValidHeaderValue(actualHeaderValue)) + { + errorMessage = $"Header mismatch: {fullHeaderName} header contains invalid characters."; + return false; + } + + var decodedActual = McpHeaderEncoder.DecodeValue(actualHeaderValue); + if (decodedActual is null) + { + errorMessage = $"Header mismatch: {fullHeaderName} header contains invalid Base64 encoding."; + return false; + } + + // Verify the header value matches the argument value in the body + if (arguments is System.Text.Json.Nodes.JsonObject argsObj && + argsObj.TryGetPropertyValue(property.Name, out var argNode) && + argNode is not null) + { + var expectedHeaderValue = McpHeaderEncoder.ConvertToHeaderValue(argNode); + if (expectedHeaderValue is not null) + { + var decodedExpected = McpHeaderEncoder.DecodeValue(expectedHeaderValue); + switch (ValuesMatch(decodedActual, decodedExpected, property.Value)) + { + case HeaderValueComparison.IntegerOutOfRange: + errorMessage = $"Header mismatch: {fullHeaderName} integer value for parameter '{property.Name}' is outside the JavaScript safe integer range (-{MaxSafeInteger} to {MaxSafeInteger})."; + return false; + case HeaderValueComparison.Mismatch: + errorMessage = $"Header mismatch: {fullHeaderName} header value does not match body argument '{property.Name}'."; + return false; + } + } + } + } + + errorMessage = null; + return true; + } + + private static string? GetJsonNodeStringProperty(System.Text.Json.Nodes.JsonNode? node, string propertyName) + { + if (node is System.Text.Json.Nodes.JsonObject obj && obj.TryGetPropertyValue(propertyName, out var value)) + { + return value?.GetValue(); + } + + return null; + } + + // Valid HTTP header field-value characters per RFC 9110: horizontal tab (0x09), + // space (0x20), and visible ASCII (0x21-0x7E). + private static readonly SearchValues s_validHeaderValueChars = + SearchValues.Create("\t !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"); + + /// + /// Validates that a header value contains only characters allowed in HTTP header field values + /// per RFC 9110: visible ASCII (0x21-0x7E), space (0x20), and horizontal tab (0x09). + /// + private static bool IsValidHeaderValue(string value) => + value.AsSpan().IndexOfAnyExcept(s_validHeaderValueChars) < 0; + + /// + /// The maximum magnitude for an integer that can be represented exactly by an IEEE 754 + /// double-precision value (2^53 - 1). Per SEP-2243 integer x-mcp-header values MUST be within + /// the JavaScript safe integer range (-2^53+1 to 2^53-1). + /// + private const long MaxSafeInteger = 9007199254740991L; + + private enum HeaderValueComparison + { + Match, + Mismatch, + IntegerOutOfRange, + } + + /// + /// Compares two decoded header values. For integer-typed parameters the values are + /// compared numerically (so cross-SDK forms such as "42" and "42.0" are treated + /// as equal) and validated against the JavaScript safe integer range per SEP-2243. + /// + private static HeaderValueComparison ValuesMatch(string? actual, string? expected, System.Text.Json.JsonElement propertySchema) + { + // Per SEP-2243, x-mcp-header may only be applied to integer, string, or boolean parameters. + // For "integer" the spec recommends numeric comparison so that representations like "42" and + // "42.0" are considered equal, while still requiring values to stay within the safe range. + // This must run before the ordinal comparison below so that an invalid integer value is + // rejected even when the header and body strings are byte-for-byte identical. + if (actual is not null && expected is not null && SchemaTypeIsInteger(propertySchema)) + { + var actualResult = ParseSafeInteger(actual, out long actualValue); + var expectedResult = ParseSafeInteger(expected, out long expectedValue); + + // A numeric value outside the safe integer range is always rejected. + if (actualResult == SafeIntegerParse.OutOfRange || expectedResult == SafeIntegerParse.OutOfRange) + { + return HeaderValueComparison.IntegerOutOfRange; + } + + if (actualResult == SafeIntegerParse.SafeInteger && expectedResult == SafeIntegerParse.SafeInteger) + { + return actualValue == expectedValue ? HeaderValueComparison.Match : HeaderValueComparison.Mismatch; + } + + // A numeric-but-non-integer value (e.g. "42.5") for an integer-typed parameter is invalid + // and must not be allowed to slip through the ordinal comparison just because the header + // and body strings happen to be identical. + if (actualResult == SafeIntegerParse.NonInteger || expectedResult == SafeIntegerParse.NonInteger) + { + return HeaderValueComparison.Mismatch; + } + + // Otherwise at least one side is not numeric at all (NotNumeric); fall through to the + // ordinal comparison below. + } + + return string.Equals(actual, expected, StringComparison.Ordinal) + ? HeaderValueComparison.Match + : HeaderValueComparison.Mismatch; + } + + /// + /// Determines whether the property schema's type keyword declares an integer type, + /// either directly or as a member of a JSON Schema union array (e.g. ["integer", "null"]). + /// + private static bool SchemaTypeIsInteger(System.Text.Json.JsonElement propertySchema) + { + if (!propertySchema.TryGetProperty("type", out var typeElement)) + { + return false; + } + + switch (typeElement.ValueKind) + { + case System.Text.Json.JsonValueKind.String: + return typeElement.ValueEquals("integer"); + + case System.Text.Json.JsonValueKind.Array: + foreach (var entry in typeElement.EnumerateArray()) + { + if (entry.ValueKind == System.Text.Json.JsonValueKind.String && entry.ValueEquals("integer")) + { + return true; + } + } + + return false; + + default: + return false; + } + } + + /// + /// Classifies how a header/body string parses as a SEP-2243 integer value. + /// + private enum SafeIntegerParse + { + /// A whole number within the JavaScript safe integer range. + SafeInteger, + + /// A numeric value whose magnitude is outside the safe integer range. + OutOfRange, + + /// A numeric value that is not a whole number (e.g. "42.5"). + NonInteger, + + /// The value is not a numeric literal at all. + NotNumeric, + } + + /// + /// Parses a header/body value as a whole integer within the JavaScript safe integer range. + /// Decimal and exponent forms whose fractional part is zero (e.g. "42.0", "4.2e1") + /// are accepted. + /// inspects the actual digits (so it rejects non-integers such as "42.5" without rounding) + /// and fails fast on overflow (so a huge literal such as "1e1000000" cannot allocate a + /// large number). + /// + private static SafeIntegerParse ParseSafeInteger(string text, out long value) + { + value = 0; + + const System.Globalization.NumberStyles Styles = + System.Globalization.NumberStyles.AllowLeadingSign | + System.Globalization.NumberStyles.AllowDecimalPoint | + System.Globalization.NumberStyles.AllowExponent; + + if (long.TryParse(text, Styles, System.Globalization.CultureInfo.InvariantCulture, out long parsed)) + { + if (parsed < -MaxSafeInteger || parsed > MaxSafeInteger) + { + return SafeIntegerParse.OutOfRange; + } + + value = parsed; + return SafeIntegerParse.SafeInteger; + } + + // The value is not representable as a 64-bit integer. Use double only as an order-of-magnitude + // gate to distinguish a numeric literal beyond the safe range (e.g. "1e100") from a numeric but + // non-integer value (e.g. "42.5"). double's loss of precision is irrelevant for this magnitude + // comparison because every in-range value was already handled exactly by long.TryParse above. + if (double.TryParse(text, Styles, System.Globalization.CultureInfo.InvariantCulture, out double d)) + { + return System.Math.Abs(d) > MaxSafeInteger ? SafeIntegerParse.OutOfRange : SafeIntegerParse.NonInteger; + } + + return SafeIntegerParse.NotNumeric; + } + + private static Task WriteJsonRpcErrorDetailAsync(HttpContext context, JsonRpcErrorDetail detail, int statusCode, RequestId requestId = default) + { + var jsonRpcError = new JsonRpcError { Id = requestId, Error = detail }; + return Results.Json(jsonRpcError, s_errorTypeInfo, statusCode: statusCode).ExecuteAsync(context); + } + private static bool MatchesApplicationJsonMediaType(MediaTypeHeaderValue acceptHeaderValue) => acceptHeaderValue.MatchesMediaType("application/json"); diff --git a/src/ModelContextProtocol.Core/AIContentExtensions.cs b/src/ModelContextProtocol.Core/AIContentExtensions.cs index bf5fd05de..affb8b20a 100644 --- a/src/ModelContextProtocol.Core/AIContentExtensions.cs +++ b/src/ModelContextProtocol.Core/AIContentExtensions.cs @@ -34,6 +34,7 @@ public static class AIContentExtensions /// /// /// is . + [Obsolete(Obsoletions.DeprecatedSampling_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public static Func, CancellationToken, ValueTask> CreateSamplingHandler( this IChatClient chatClient, JsonSerializerOptions? serializerOptions = null) diff --git a/src/ModelContextProtocol.Core/Authentication/AuthorizationCallbackContext.cs b/src/ModelContextProtocol.Core/Authentication/AuthorizationCallbackContext.cs new file mode 100644 index 000000000..cbc453802 --- /dev/null +++ b/src/ModelContextProtocol.Core/Authentication/AuthorizationCallbackContext.cs @@ -0,0 +1,17 @@ +namespace ModelContextProtocol.Authentication; + +/// +/// Provides the information needed to complete an OAuth authorization request. +/// +public sealed class AuthorizationCallbackContext +{ + /// + /// Gets the authorization URI that the user needs to visit. + /// + public required Uri AuthorizationUri { get; init; } + + /// + /// Gets the redirect URI where the authorization response will be sent. + /// + public required Uri RedirectUri { get; init; } +} diff --git a/src/ModelContextProtocol.Core/Authentication/AuthorizationRedirectDelegate.cs b/src/ModelContextProtocol.Core/Authentication/AuthorizationRedirectDelegate.cs index a811e51cc..b8f6a37cd 100644 --- a/src/ModelContextProtocol.Core/Authentication/AuthorizationRedirectDelegate.cs +++ b/src/ModelContextProtocol.Core/Authentication/AuthorizationRedirectDelegate.cs @@ -1,4 +1,3 @@ - namespace ModelContextProtocol.Authentication; /// @@ -9,20 +8,13 @@ namespace ModelContextProtocol.Authentication; /// The to monitor for cancellation requests. The default is . /// A task that represents the asynchronous operation. The task result contains the authorization code if successful, or null if the operation failed or was cancelled. /// -/// -/// This delegate provides SDK consumers with full control over how the OAuth authorization flow is handled. -/// Implementers can choose to: -/// -/// -/// Start a local HTTP server and open a browser (default behavior) -/// Display the authorization URL to the user for manual handling -/// Integrate with a custom UI or authentication flow -/// Use a different redirect mechanism altogether -/// -/// -/// The implementation should handle user interaction to visit the authorization URL and extract -/// the authorization code from the callback. The authorization code is typically provided as -/// a query parameter in the redirect URI callback. -/// +/// This delegate cannot return the iss parameter from the authorization response, so +/// RFC 9207 issuer validation is +/// skipped when it is used. Use for +/// issuer-aware authorization flows. /// -public delegate Task AuthorizationRedirectDelegate(Uri authorizationUri, Uri redirectUri, CancellationToken cancellationToken); \ No newline at end of file +[Obsolete( + ModelContextProtocol.Obsoletions.AuthorizationRedirectDelegate_Message, + DiagnosticId = ModelContextProtocol.Obsoletions.AuthorizationRedirectDelegate_DiagnosticId, + UrlFormat = ModelContextProtocol.Obsoletions.AuthorizationRedirectDelegate_Url)] +public delegate Task AuthorizationRedirectDelegate(Uri authorizationUri, Uri redirectUri, CancellationToken cancellationToken); diff --git a/src/ModelContextProtocol.Core/Authentication/AuthorizationResult.cs b/src/ModelContextProtocol.Core/Authentication/AuthorizationResult.cs new file mode 100644 index 000000000..4da082f7b --- /dev/null +++ b/src/ModelContextProtocol.Core/Authentication/AuthorizationResult.cs @@ -0,0 +1,54 @@ +namespace ModelContextProtocol.Authentication; + +/// +/// Represents the result of an OAuth authorization redirect, containing the authorization code, +/// state, and optionally the issuer identifier from the authorization response. +/// +/// +/// +/// The property must be populated from the state query parameter in the +/// redirect URI. The SDK validates it against the value sent in the authorization request to bind +/// the response to the initiating transaction and mitigate cross-site request forgery attacks. +/// +/// +/// The property should be populated from the iss query parameter in the +/// redirect URI when present, as specified by +/// RFC 9207. +/// This enables the SDK to validate that the authorization response originated from the expected +/// authorization server, mitigating mix-up attacks. +/// +/// +public sealed class AuthorizationResult +{ + /// + /// Gets the authorization code returned by the authorization server. + /// + public string? Code { get; init; } + + /// + /// Gets the state value returned in the authorization response. + /// + /// + /// Implementations of must populate this + /// property from the state query parameter of the redirect URI callback. The SDK requires an + /// exact match with the state sent in the authorization request before exchanging the authorization code. + /// + public string? State { get; init; } + + /// + /// Gets the issuer identifier returned in the authorization response per + /// RFC 9207. + /// + /// + /// + /// This value should be extracted from the iss query parameter of the redirect URI. + /// When present, the SDK validates it against the expected authorization server issuer to + /// prevent mix-up attacks. + /// + /// + /// Implementations of should populate this + /// property whenever the iss parameter is present in the redirect URI callback. + /// + /// + public string? Iss { get; init; } +} diff --git a/src/ModelContextProtocol.Core/Authentication/AuthorizationServerMetadata.cs b/src/ModelContextProtocol.Core/Authentication/AuthorizationServerMetadata.cs index 87df29636..d8d684a3b 100644 --- a/src/ModelContextProtocol.Core/Authentication/AuthorizationServerMetadata.cs +++ b/src/ModelContextProtocol.Core/Authentication/AuthorizationServerMetadata.cs @@ -72,4 +72,11 @@ internal sealed class AuthorizationServerMetadata /// [JsonPropertyName("client_id_metadata_document_supported")] public bool ClientIdMetadataDocumentSupported { get; set; } + + /// + /// Indicates whether the authorization server includes the iss parameter in authorization responses + /// as defined in RFC 9207. + /// + [JsonPropertyName("authorization_response_iss_parameter_supported")] + public bool AuthorizationResponseIssParameterSupported { get; set; } } diff --git a/src/ModelContextProtocol.Core/Authentication/ClientOAuthOptions.cs b/src/ModelContextProtocol.Core/Authentication/ClientOAuthOptions.cs index 483e3643e..df1c44c1f 100644 --- a/src/ModelContextProtocol.Core/Authentication/ClientOAuthOptions.cs +++ b/src/ModelContextProtocol.Core/Authentication/ClientOAuthOptions.cs @@ -35,32 +35,82 @@ public sealed class ClientOAuthOptions public Uri? ClientMetadataDocumentUri { get; set; } /// - /// Gets or sets the OAuth scopes to request. + /// Gets or sets the OAuth scopes to request as a fallback. /// /// /// - /// When specified, these scopes will be used instead of the scopes advertised by the protected resource. - /// If not specified, the provider will use the scopes from the protected resource metadata. + /// These scopes are used only when the server does not provide scope information via the + /// WWW-Authenticate header or Protected Resource Metadata (scopes_supported). This + /// matches the MCP scope selection strategy: WWW-Authenticate scope → PRM scopes_supported → + /// client-configured scopes → omit scope parameter. /// /// - /// Common OAuth scopes include "openid", "profile", and "email". + /// To filter or customize scopes when the server does provide scope information, + /// use instead. /// /// public IEnumerable? Scopes { get; set; } /// - /// Gets or sets the authorization redirect delegate for handling the OAuth authorization flow. + /// Gets or sets a delegate that selects or filters the OAuth scopes to request. /// /// /// - /// This delegate is responsible for handling the OAuth authorization URL and obtaining the authorization code. - /// If not specified, a default implementation will be used that prompts the user to enter the code manually. + /// When set, this delegate is called after the MCP scope selection strategy has determined the + /// candidate scopes (WWW-Authenticate → PRM scopes_supported → fallback) + /// and after offline_access has been automatically appended when advertised by the + /// authorization server. The return value replaces the candidate scopes in the authorization request. + /// + /// + /// Use this to request only a subset of the scopes offered by the server, or to append a custom + /// scope that is not advertised in the server metadata. Return or an empty + /// enumerable to omit the scope parameter entirely. + /// + /// + public ScopeSelectorDelegate? ScopeSelector { get; set; } + + /// + /// Gets or sets the callback that handles the OAuth authorization flow. + /// + /// + /// + /// This callback receives the authorization and redirect URIs in an + /// and returns the authorization response. + /// If not specified, a default implementation prompts the user to enter the full redirect URL manually. /// /// /// Custom implementations might open a browser, start an HTTP listener, or use other mechanisms to capture - /// the authorization code from the OAuth redirect. + /// the authorization response. They must return the code and state query parameters, + /// and should return the iss query parameter when present, from the redirect URI callback. + /// The SDK requires an exact state match before exchanging the code. Returning iss enables + /// the SDK to validate the parameter per + /// RFC 9207, which mitigates + /// mix-up attacks. + /// + /// + /// This property cannot be configured together with . + /// + /// + public Func>? AuthorizationCallbackHandler { get; set; } + + /// + /// Gets or sets the legacy authorization redirect delegate for handling the OAuth authorization flow. + /// + /// + /// + /// This delegate returns only the authorization code and cannot provide the state or iss + /// parameter from the authorization response. Consequently, state and RFC 9207 issuer validation are + /// skipped when this delegate is used. Use for response-bound, + /// issuer-aware authorization flows. + /// + /// + /// This property cannot be configured together with . /// /// + [Obsolete( + ModelContextProtocol.Obsoletions.AuthorizationRedirectDelegate_Message, + DiagnosticId = ModelContextProtocol.Obsoletions.AuthorizationRedirectDelegate_DiagnosticId, + UrlFormat = ModelContextProtocol.Obsoletions.AuthorizationRedirectDelegate_Url)] public AuthorizationRedirectDelegate? AuthorizationRedirectDelegate { get; set; } /// @@ -92,8 +142,9 @@ public sealed class ClientOAuthOptions /// /// /// - /// Parameters specified cannot override or append to any automatically set parameters like the "redirect_uri", - /// which should instead be configured via . + /// Parameters specified cannot override or append to any automatically set parameters like + /// redirect_uri or state. The redirect URI should instead be configured via + /// , while state is generated uniquely for each authorization transaction. /// /// public IDictionary AdditionalAuthorizationParameters { get; set; } = new Dictionary(); diff --git a/src/ModelContextProtocol.Core/Authentication/ClientOAuthProvider.cs b/src/ModelContextProtocol.Core/Authentication/ClientOAuthProvider.cs index ecef8e15e..785e3cc2e 100644 --- a/src/ModelContextProtocol.Core/Authentication/ClientOAuthProvider.cs +++ b/src/ModelContextProtocol.Core/Authentication/ClientOAuthProvider.cs @@ -28,15 +28,20 @@ internal sealed partial class ClientOAuthProvider : McpHttpClient private readonly Uri _serverUrl; private readonly Uri _redirectUri; private readonly string? _configuredScopes; + private readonly ScopeSelectorDelegate? _scopeSelector; private readonly IDictionary _additionalAuthorizationParameters; private readonly Func, Uri?> _authServerSelector; - private readonly AuthorizationRedirectDelegate _authorizationRedirectDelegate; + private readonly Func> _authorizationCallbackHandler; + private readonly bool _validateAuthorizationResponseState; + private readonly bool _validateAuthorizationResponseIssuer; private readonly Uri? _clientMetadataDocumentUri; + private readonly string? _configuredClientId; - // _dcrClientName, _dcrClientUri, _dcrInitialAccessToken and _dcrResponseDelegate are used for dynamic client registration (RFC 7591) + // _dcrClientName, _dcrClientUri, _dcrInitialAccessToken, _dcrConfiguredApplicationType and _dcrResponseDelegate are used for dynamic client registration (RFC 7591) private readonly string? _dcrClientName; private readonly Uri? _dcrClientUri; private readonly string? _dcrInitialAccessToken; + private readonly string? _dcrConfiguredApplicationType; private readonly Func? _dcrResponseDelegate; private readonly HttpClient _httpClient; @@ -45,9 +50,29 @@ internal sealed partial class ClientOAuthProvider : McpHttpClient private string? _clientId; private string? _clientSecret; private string? _tokenEndpointAuthMethod; + private string? _clientCredentialsAuthorizationServer; private ITokenCache _tokenCache; private AuthorizationServerMetadata? _authServerMetadata; + // Coalesces concurrent token acquisition so that when multiple in-flight requests observe an + // expired token (or a 401) at the same time, only the first runs the refresh/authorization flow + // while the others await its result. This also serializes all reads and writes to the mutable auth + // state below (_authServerMetadata, _clientId, _clientSecret, _tokenEndpointAuthMethod) as well as + // the accumulated scope set and step-up tracking (_accumulatedScopes, _hasAttemptedStepUp), so those + // fields need no separate lock. + // + // Intentionally not disposed: this instance is only ever used via WaitAsync/Release (never its + // AvailableWaitHandle), so SemaphoreSlim allocates no unmanaged resource and there is nothing to + // dispose. Do not access AvailableWaitHandle, or this field will need deterministic disposal. + private readonly SemaphoreSlim _tokenAcquisitionLock = new(1, 1); + // The accumulated scope set lives for this provider's lifetime and is intentionally not keyed by + // resource or authorization server. This is safe today because one ClientOAuthProvider is created + // per HttpClientTransport, i.e. per endpoint/resource. If a provider were ever reused across + // multiple resources or auth servers, accumulated scopes could be sent to a server that rejects + // them (invalid_scope). Accumulation is scoped per "resource and operation" combination (SEP-2350). + private readonly HashSet _accumulatedScopes = new(StringComparer.Ordinal); + private bool _hasAttemptedStepUp; + /// /// Initializes a new instance of the class using the specified options. /// @@ -73,22 +98,59 @@ public ClientOAuthProvider( } _clientId = options.ClientId; + _configuredClientId = options.ClientId; _clientSecret = options.ClientSecret; _redirectUri = options.RedirectUri ?? throw new ArgumentException("ClientOAuthOptions.RedirectUri must configured.", nameof(options)); _configuredScopes = options.Scopes is null ? null : string.Join(" ", options.Scopes); + _scopeSelector = options.ScopeSelector; _additionalAuthorizationParameters = options.AdditionalAuthorizationParameters; _clientMetadataDocumentUri = options.ClientMetadataDocumentUri; // Set up authorization server selection strategy _authServerSelector = options.AuthServerSelector ?? DefaultAuthServerSelector; - // Set up authorization URL handler (use default if not provided) - _authorizationRedirectDelegate = options.AuthorizationRedirectDelegate ?? DefaultAuthorizationUrlHandler; + // Set up authorization callback handler (use default if not provided). +#pragma warning disable MCP9007 // Read the obsolete property to provide source and binary compatibility. + var authorizationRedirectDelegate = options.AuthorizationRedirectDelegate; + + if (options.AuthorizationCallbackHandler is not null && authorizationRedirectDelegate is not null) + { + throw new ArgumentException( + $"{nameof(ClientOAuthOptions.AuthorizationCallbackHandler)} and {nameof(ClientOAuthOptions.AuthorizationRedirectDelegate)} cannot both be configured.", + nameof(options)); + } +#pragma warning restore MCP9007 + + if (options.AuthorizationCallbackHandler is not null) + { + _authorizationCallbackHandler = options.AuthorizationCallbackHandler; + _validateAuthorizationResponseState = true; + _validateAuthorizationResponseIssuer = true; + } + else if (authorizationRedirectDelegate is not null) + { + _authorizationCallbackHandler = async (context, cancellationToken) => new AuthorizationResult + { + Code = await authorizationRedirectDelegate( + context.AuthorizationUri, + context.RedirectUri, + cancellationToken).ConfigureAwait(false), + }; + _validateAuthorizationResponseState = false; + _validateAuthorizationResponseIssuer = false; + } + else + { + _authorizationCallbackHandler = DefaultAuthorizationUrlHandler; + _validateAuthorizationResponseState = true; + _validateAuthorizationResponseIssuer = true; + } _dcrClientName = options.DynamicClientRegistration?.ClientName; _dcrClientUri = options.DynamicClientRegistration?.ClientUri; _dcrInitialAccessToken = options.DynamicClientRegistration?.InitialAccessToken; _dcrResponseDelegate = options.DynamicClientRegistration?.ResponseDelegate; + _dcrConfiguredApplicationType = options.DynamicClientRegistration?.ApplicationType; _tokenCache = options.TokenCache ?? new InMemoryTokenCache(); } @@ -100,20 +162,33 @@ public ClientOAuthProvider( private static Uri? DefaultAuthServerSelector(IReadOnlyList availableServers) => availableServers.FirstOrDefault(); /// - /// Default authorization URL handler that displays the URL to the user for manual input. + /// Default authorization URL handler that displays the URL to the user and parses the resulting redirect URL. /// - /// The authorization URL to handle. - /// The redirect URI where the authorization code will be sent. + /// The context containing the authorization and redirect URIs. /// The to monitor for cancellation requests. - /// The authorization code entered by the user, or null if none was provided. - private static Task DefaultAuthorizationUrlHandler(Uri authorizationUrl, Uri redirectUri, CancellationToken cancellationToken) + /// The authorization result parsed from the redirect URL. + private static Task DefaultAuthorizationUrlHandler( + AuthorizationCallbackContext context, + CancellationToken cancellationToken) { Console.WriteLine($"Please open the following URL in your browser to authorize the application:"); - Console.WriteLine($"{authorizationUrl}"); + Console.WriteLine($"{context.AuthorizationUri}"); Console.WriteLine(); - Console.Write("Enter the authorization code from the redirect URL: "); - var authorizationCode = Console.ReadLine(); - return Task.FromResult(authorizationCode); + Console.Write("Enter the full redirect URL: "); + var redirectUrl = Console.ReadLine(); + if (!Uri.TryCreate(redirectUrl, UriKind.Absolute, out var responseUri)) + { + ThrowFailedToHandleUnauthorizedResponse( + "The entered redirect URL is not a valid absolute URL. Paste the full redirect URL from the browser address bar."); + } + + var queryParams = HttpUtility.ParseQueryString(responseUri.Query); + return Task.FromResult(new() + { + Code = queryParams["code"], + State = queryParams["state"], + Iss = queryParams["iss"], + }); } internal override async Task SendAsync(HttpRequestMessage request, JsonRpcMessage? message, CancellationToken cancellationToken) @@ -135,7 +210,10 @@ internal override async Task SendAsync(HttpRequestMessage r if (ShouldRetryWithNewAccessToken(response)) { - return await HandleUnauthorizedResponseAsync(request, message, response, attemptedRefresh, cancellationToken).ConfigureAwait(false); + // Capture the token that produced this challenge so the retry path can detect whether + // another concurrent caller already replaced it in the cache. + var usedAccessToken = request.Headers.Authorization?.Parameter; + return await HandleUnauthorizedResponseAsync(request, message, response, attemptedRefresh, usedAccessToken, cancellationToken).ConfigureAwait(false); } return response; @@ -151,15 +229,34 @@ internal override async Task SendAsync(HttpRequestMessage r return (tokens.AccessToken, false); } - // Try to refresh the access token if it is invalid and we have a refresh token. - if (_authServerMetadata is not null && tokens?.RefreshToken is { Length: > 0 } refreshToken) + // A refresh is only possible if we have both the auth server metadata and a refresh token. + if (_authServerMetadata is null || tokens?.RefreshToken is not { Length: > 0 }) + { + // No valid token - auth handler will trigger the 401 flow + return (null, false); + } + + // Serialize the refresh so concurrent callers that all saw the expired token don't each fire + // their own refresh. Waiters re-check the cache after acquiring the lock and reuse the token + // produced by whoever refreshed first. + using var _ = await _tokenAcquisitionLock.LockAsync(cancellationToken).ConfigureAwait(false); + + var current = await _tokenCache.GetTokensAsync(cancellationToken).ConfigureAwait(false); + if (current is not null && !current.IsExpired) + { + return (current.AccessToken, true); + } + + if (_authServerMetadata is not null && + current?.RefreshToken is { Length: > 0 } refreshToken && + CachedTokensMatchClientCredentials(current, _clientCredentialsAuthorizationServer)) { var accessToken = await RefreshTokensAsync(refreshToken, resourceUri.ToString(), _authServerMetadata, cancellationToken).ConfigureAwait(false); return (accessToken, true); } // No valid token - auth handler will trigger the 401 flow - return (null, false); + return (null, true); } private static bool ShouldRetryWithNewAccessToken(HttpResponseMessage response) @@ -198,6 +295,7 @@ private async Task HandleUnauthorizedResponseAsync( JsonRpcMessage? originalJsonRpcMessage, HttpResponseMessage response, bool attemptedRefresh, + string? usedAccessToken, CancellationToken cancellationToken) { if (response.Headers.WwwAuthenticate.Count == 0) @@ -210,7 +308,7 @@ private async Task HandleUnauthorizedResponseAsync( throw new McpException($"The server does not support the '{BearerScheme}' authentication scheme. Server supports: [{serverSchemes}]."); } - var accessToken = await GetAccessTokenAsync(response, attemptedRefresh, cancellationToken).ConfigureAwait(false); + var accessToken = await GetAccessTokenAsync(response, attemptedRefresh, usedAccessToken, cancellationToken).ConfigureAwait(false); using var retryRequest = new HttpRequestMessage(originalRequest.Method, originalRequest.RequestUri); @@ -231,8 +329,31 @@ private async Task HandleUnauthorizedResponseAsync( /// /// The HTTP response that triggered the authentication challenge. /// Indicates whether a token refresh has already been attempted. + /// The access token that produced the challenge, or if none was sent. /// The to monitor for cancellation requests. - private async Task GetAccessTokenAsync(HttpResponseMessage response, bool attemptedRefresh, CancellationToken cancellationToken) + private async Task GetAccessTokenAsync(HttpResponseMessage response, bool attemptedRefresh, string? usedAccessToken, CancellationToken cancellationToken) + { + // Serialize the authorization flow so concurrent 401/403 challenges don't each run a full + // refresh/registration/interactive authorization and race on the shared auth state below. + using var _ = await _tokenAcquisitionLock.LockAsync(cancellationToken).ConfigureAwait(false); + + // While we waited for the lock, another concurrent caller may have already acquired or + // refreshed the token. Reuse the cached token if it is both still valid and different from + // the one that produced this challenge (otherwise we'd just replay the rejected token). When + // no token was sent (usedAccessToken is null, e.g. concurrent cold-start requests), any valid + // cached token was obtained by another caller and is safe to reuse. This is limited to 401; a + // 403 insufficient_scope challenge must still run the step-up flow. + if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized && + await _tokenCache.GetTokensAsync(cancellationToken).ConfigureAwait(false) is { IsExpired: false } cached && + !string.Equals(cached.AccessToken, usedAccessToken, StringComparison.Ordinal)) + { + return cached.AccessToken; + } + + return await GetAccessTokenCoreAsync(response, attemptedRefresh, usedAccessToken, cancellationToken).ConfigureAwait(false); + } + + private async Task GetAccessTokenCoreAsync(HttpResponseMessage response, bool attemptedRefresh, string? usedAccessToken, CancellationToken cancellationToken) { // Get available authorization servers from the 401 or 403 response var protectedResourceMetadata = await ExtractProtectedResourceMetadata(response, cancellationToken).ConfigureAwait(false); @@ -243,6 +364,37 @@ private async Task GetAccessTokenAsync(HttpResponseMessage response, boo ThrowFailedToHandleUnauthorizedResponse("No authorization servers found in authentication challenge"); } + // SEP-2350: A step-up may legitimately introduce new scopes, so at least one interactive + // (re-)authorization attempt is always allowed. However, once a step-up has already been + // attempted, a subsequent insufficient_scope challenge that introduces no scope beyond those + // already requested cannot make progress by re-running authorization. Treat that repeated, + // unproductive challenge as a permanent authorization failure instead of prompting the user + // again for the same resource and operation combination. + if (response.StatusCode == System.Net.HttpStatusCode.Forbidden) + { + bool introducesNewScopes = ChallengeIntroducesNewScopes(protectedResourceMetadata); + if (_hasAttemptedStepUp && !introducesNewScopes) + { + // A step-up has already run and this challenge asks for nothing new. If that step-up + // produced a different, still-valid token (for example another concurrent caller ran + // it while this one waited on the lock), reuse that token instead of failing, since it + // already reflects the accumulated scopes. Only fail when there is no newer token to + // try, which is the genuine repeated-failure case where the stepped-up token itself + // was rejected again. + if (await _tokenCache.GetTokensAsync(cancellationToken).ConfigureAwait(false) is { IsExpired: false } steppedUpToken && + !string.Equals(steppedUpToken.AccessToken, usedAccessToken, StringComparison.Ordinal)) + { + return steppedUpToken.AccessToken; + } + + ThrowFailedToHandleUnauthorizedResponse( + "A repeated insufficient_scope challenge added no scope beyond those already requested, " + + "so step-up authorization cannot satisfy the request."); + } + + _hasAttemptedStepUp = true; + } + // Convert string URIs to Uri objects for the selector List authServerUris = []; foreach (var serverUriString in availableAuthorizationServers) @@ -275,13 +427,28 @@ private async Task GetAccessTokenAsync(HttpResponseMessage response, boo // The existing access token must be invalid to have resulted in a 401 response, but refresh might still work. var resourceUri = GetResourceUri(protectedResourceMetadata); + // Restore any client registration persisted alongside the tokens. On a cold start a durable + // token cache may hold a refresh token together with the client ID it was issued to, while this + // provider has not assigned a client ID yet. Restoring it here makes the refresh below possible + // and avoids a redundant dynamic client registration in the assignment block. + var cachedTokens = await _tokenCache.GetTokensAsync(cancellationToken).ConfigureAwait(false); + RestoreCachedClientCredentials(cachedTokens, selectedAuthServer); + BindClientCredentialsToAuthorizationServer(selectedAuthServer); + var cachedTokensMatchClientCredentials = + CachedTokensMatchClientCredentials(cachedTokens, selectedAuthServer.OriginalString); + // Only attempt a token refresh if we haven't attempted to already for this request. // Also only attempt a token refresh for a 401 Unauthorized responses. Other response status codes - // should not be used for expired access tokens. This is important because 403 forbiden responses can - // be used for incremental consent which cannot be acheived with a simple refresh. + // should not be used for expired access tokens. This is important because 403 forbidden responses can + // be used for incremental consent which cannot be achieved with a simple refresh. + // A refresh also requires a client ID. On a cold start one may not be available yet (and could not + // be restored from the cache), in which case we fall through to the client-ID assignment block and + // the authorization-code flow below rather than throwing. if (!attemptedRefresh && response.StatusCode == System.Net.HttpStatusCode.Unauthorized && - await _tokenCache.GetTokensAsync(cancellationToken).ConfigureAwait(false) is { RefreshToken: { Length: > 0 } refreshToken }) + !string.IsNullOrEmpty(_clientId) && + cachedTokensMatchClientCredentials && + cachedTokens is { RefreshToken: { Length: > 0 } refreshToken }) { var accessToken = await RefreshTokensAsync(refreshToken, resourceUri, authServerMetadata, cancellationToken).ConfigureAwait(false); if (accessToken is not null) @@ -305,6 +472,8 @@ await _tokenCache.GetTokensAsync(cancellationToken).ConfigureAwait(false) is { R } } + _clientCredentialsAuthorizationServer = selectedAuthServer.OriginalString; + // Determine the token endpoint auth method from server metadata if not already set by DCR. _tokenEndpointAuthMethod ??= authServerMetadata.TokenEndpointAuthMethodsSupported?.FirstOrDefault(); @@ -334,8 +503,15 @@ static bool IsValidClientMetadataDocumentUri(Uri uri) private async Task GetAuthServerMetadataAsync(Uri authServerUri, string? resourceUri, CancellationToken cancellationToken) { + // Tracks whether at least one well-known endpoint returned a structurally valid metadata document. + // This distinguishes "no metadata document was found" (eligible for the 2025-03-26 legacy fallback) + // from "a metadata document exists but failed PKCE validation" (must not fall back to synthesized defaults). + var metadataDocumentFound = false; + McpException? pkceValidationFailure = null; + foreach (var wellKnownEndpoint in GetWellKnownAuthorizationServerMetadataUris(authServerUri)) { + AuthorizationServerMetadata? metadata; try { var response = await _httpClient.GetAsync(wellKnownEndpoint, cancellationToken).ConfigureAwait(false); @@ -345,7 +521,7 @@ private async Task GetAuthServerMetadataAsync(Uri a } using var stream = await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false); - var metadata = await JsonSerializer.DeserializeAsync(stream, McpJsonUtilities.JsonContext.Default.AuthorizationServerMetadata, cancellationToken).ConfigureAwait(false); + metadata = await JsonSerializer.DeserializeAsync(stream, McpJsonUtilities.JsonContext.Default.AuthorizationServerMetadata, cancellationToken).ConfigureAwait(false); if (metadata is null) { @@ -363,23 +539,94 @@ private async Task GetAuthServerMetadataAsync(Uri a ThrowFailedToHandleUnauthorizedResponse($"AuthorizationEndpoint must use HTTP or HTTPS. '{metadata.AuthorizationEndpoint}' does not meet this requirement."); } - metadata.ResponseTypesSupported ??= ["code"]; - metadata.GrantTypesSupported ??= ["authorization_code", "refresh_token"]; - metadata.TokenEndpointAuthMethodsSupported ??= ["client_secret_post"]; - metadata.CodeChallengeMethodsSupported ??= ["S256"]; + // Validate the issuer in the metadata document per RFC 8414 Section 3.3: + // the issuer value MUST be identical to the issuer identifier used to construct + // the well-known URL. + // Skip validation in legacy backcompat mode (resourceUri is null) because the + // authServerUri was derived from the server origin rather than from Protected + // Resource Metadata, so it may not match the server's canonical issuer. + // Note: resourceUri is null exclusively in the 2025-03-26 legacy path. For newer + // protocol versions, ExtractProtectedResourceMetadata throws if the PRM document + // omits the resource field (VerifyResourceMatch returns false for null Resource), + // so we never reach this point with resourceUri == null in non-legacy flows. + if (resourceUri is not null && metadata.Issuer is null) + { + ThrowFailedToHandleUnauthorizedResponse( + $"Authorization server metadata from '{wellKnownEndpoint}' did not provide the required issuer (RFC 8414 Section 2)."); + } - return metadata; + // RFC 8414 requires an identical issuer value, so do not normalize URI case, + // trailing slashes, or percent-encoding before comparison. + if (resourceUri is not null && + !string.Equals(metadata.Issuer!.OriginalString, authServerUri.OriginalString, StringComparison.Ordinal)) + { + ThrowFailedToHandleUnauthorizedResponse( + $"Authorization server metadata issuer '{metadata.Issuer}' does not match the expected issuer '{authServerUri}' (RFC 8414 Section 3.3)."); + } + + // A structurally valid metadata document was discovered. Even if it fails PKCE validation + // below, its existence disqualifies the legacy fallback that would otherwise synthesize S256. + metadataDocumentFound = true; + } + catch (McpException) + { + // Metadata validation failures are security signals and must not fall back to + // another well-known endpoint. + throw; } catch (Exception ex) { LogErrorFetchingAuthServerMetadata(ex, wellKnownEndpoint); + continue; } + + try + { + // Per the MCP spec, clients MUST verify PKCE support via authorization server metadata and refuse + // to proceed without it. Rather than failing on the first document that lacks it, skip to the next + // discovery endpoint: different well-known endpoints (OAuth 2.0 vs OpenID Connect) can return + // different documents for the same server, and OpenID Connect metadata commonly includes the field. + var codeChallengeMethods = metadata.CodeChallengeMethodsSupported; + if (codeChallengeMethods is null) + { + ThrowFailedToHandleUnauthorizedResponse( + $"Authorization server metadata from '{wellKnownEndpoint}' does not include 'code_challenge_methods_supported'. MCP clients require PKCE support and must refuse to proceed."); + } + + if (!codeChallengeMethods.Contains("S256")) + { + var advertisedMethods = codeChallengeMethods.Count > 0 + ? string.Join(", ", codeChallengeMethods) + : ""; + ThrowFailedToHandleUnauthorizedResponse( + $"Authorization server metadata from '{wellKnownEndpoint}' does not advertise required PKCE method 'S256' in 'code_challenge_methods_supported'. Advertised methods: {advertisedMethods}."); + } + } + catch (Exception ex) + { + LogAuthServerMetadataMissingPkceSupport(ex, wellKnownEndpoint); + pkceValidationFailure = ex as McpException ?? new McpException(ex.Message, ex); + continue; + } + + metadata.ResponseTypesSupported ??= ["code"]; + metadata.GrantTypesSupported ??= ["authorization_code", "refresh_token"]; + metadata.TokenEndpointAuthMethodsSupported ??= ["client_secret_post"]; + + return metadata; + } + + // A discovered metadata document that failed PKCE validation must not be replaced with synthesized + // defaults. Surface the specific PKCE failure regardless of whether PRM was available. + if (metadataDocumentFound && pkceValidationFailure is not null) + { + throw pkceValidationFailure; } if (resourceUri is null) { - // 2025-03-26 backcompat: when PRM is unavailable and auth server metadata discovery - // also fails, fall back to default endpoint paths per the 2025-03-26 spec. + // 2025-03-26 backcompat: when PRM is unavailable and no auth server metadata document was + // discovered, fall back to default endpoint paths per the 2025-03-26 spec. return BuildDefaultAuthServerMetadata(authServerUri); } @@ -456,24 +703,53 @@ private async Task InitiateAuthorizationCodeFlowAsync( AuthorizationServerMetadata authServerMetadata, CancellationToken cancellationToken) { - var codeVerifier = GenerateCodeVerifier(); + var codeVerifier = GenerateRandomBase64UrlValue(); var codeChallenge = GenerateCodeChallenge(codeVerifier); + var state = GenerateRandomBase64UrlValue(); + + var authUrl = BuildAuthorizationUrl(protectedResourceMetadata, authServerMetadata, codeChallenge, state); + + var authResult = await _authorizationCallbackHandler( + new AuthorizationCallbackContext + { + AuthorizationUri = authUrl, + RedirectUri = _redirectUri, + }, + cancellationToken).ConfigureAwait(false); + + if (authResult is null) + { + ThrowFailedToHandleUnauthorizedResponse($"The {nameof(ClientOAuthOptions.AuthorizationCallbackHandler)} returned a null authorization result."); + } + + if (_validateAuthorizationResponseState) + { + ValidateStateResponse(authResult!.State, state); + } - var authUrl = BuildAuthorizationUrl(protectedResourceMetadata, authServerMetadata, codeChallenge); - var authCode = await _authorizationRedirectDelegate(authUrl, _redirectUri, cancellationToken).ConfigureAwait(false); + if (string.IsNullOrEmpty(authResult.Code)) + { + ThrowFailedToHandleUnauthorizedResponse("The authorization callback returned a null or empty authorization code."); + } - if (string.IsNullOrEmpty(authCode)) + if (_validateAuthorizationResponseIssuer) { - ThrowFailedToHandleUnauthorizedResponse($"The {nameof(AuthorizationRedirectDelegate)} returned a null or empty authorization code."); + ValidateIssuerResponse(authResult!.Iss, authServerMetadata); } - return await ExchangeCodeForTokenAsync(protectedResourceMetadata, authServerMetadata, authCode!, codeVerifier, cancellationToken).ConfigureAwait(false); + return await ExchangeCodeForTokenAsync( + protectedResourceMetadata, + authServerMetadata, + authResult.Code!, + codeVerifier, + cancellationToken).ConfigureAwait(false); } private Uri BuildAuthorizationUrl( ProtectedResourceMetadata protectedResourceMetadata, AuthorizationServerMetadata authServerMetadata, - string codeChallenge) + string codeChallenge, + string state) { var resourceUri = GetResourceUri(protectedResourceMetadata); @@ -484,6 +760,7 @@ private Uri BuildAuthorizationUrl( ["response_type"] = "code", ["code_challenge"] = codeChallenge, ["code_challenge_method"] = "S256", + ["state"] = state, }; if (resourceUri is not null) @@ -491,7 +768,7 @@ private Uri BuildAuthorizationUrl( queryParamsDictionary["resource"] = resourceUri; } - var scope = GetScopeParameter(protectedResourceMetadata); + var scope = ComputeEffectiveScope(protectedResourceMetadata, authServerMetadata); if (!string.IsNullOrEmpty(scope)) { queryParamsDictionary["scope"] = scope!; @@ -604,6 +881,12 @@ private async Task HandleSuccessfulTokenResponseAsync(HttpRespon TokenType = tokenResponse.TokenType, Scope = tokenResponse.Scope, ObtainedAt = DateTimeOffset.UtcNow, + // Persist the client registration alongside the tokens so a durable cache can use the + // refresh token after a process restart without re-running dynamic client registration. + ClientId = _clientId, + ClientSecret = _clientSecret, + TokenEndpointAuthMethod = _tokenEndpointAuthMethod, + AuthorizationServer = _clientCredentialsAuthorizationServer, }; await _tokenCache.StoreTokensAsync(tokens, cancellationToken).ConfigureAwait(false); @@ -645,6 +928,7 @@ private async Task PerformDynamicClientRegistrationAsync( LogPerformingDynamicClientRegistration(authServerMetadata.RegistrationEndpoint); + var dcrApplicationType = ResolveApplicationType(_dcrConfiguredApplicationType, _redirectUri); var registrationRequest = new DynamicClientRegistrationRequest { RedirectUris = [_redirectUri.ToString()], @@ -653,7 +937,8 @@ private async Task PerformDynamicClientRegistrationAsync( TokenEndpointAuthMethod = "client_secret_post", ClientName = _dcrClientName, ClientUri = _dcrClientUri?.ToString(), - Scope = GetScopeParameter(protectedResourceMetadata), + Scope = ComputeEffectiveScope(protectedResourceMetadata, authServerMetadata), + ApplicationType = dcrApplicationType, }; var requestBytes = JsonSerializer.SerializeToUtf8Bytes(registrationRequest, McpJsonUtilities.JsonContext.Default.DynamicClientRegistrationRequest); @@ -675,7 +960,9 @@ private async Task PerformDynamicClientRegistrationAsync( if (!httpResponse.IsSuccessStatusCode) { var errorContent = await httpResponse.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false); - ThrowFailedToHandleUnauthorizedResponse($"Dynamic client registration failed with status {httpResponse.StatusCode}: {errorContent}"); + ThrowFailedToHandleUnauthorizedResponse( + $"Dynamic client registration failed with status {httpResponse.StatusCode}: {errorContent} " + + $"(application_type: '{dcrApplicationType}', redirect_uri: '{_redirectUri}')."); } using var responseStream = await httpResponse.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false); @@ -709,33 +996,231 @@ private async Task PerformDynamicClientRegistrationAsync( } } + private static string ResolveApplicationType(string? configuredApplicationType, Uri redirectUri) + => configuredApplicationType ?? InferApplicationType(redirectUri); + + private static string InferApplicationType(Uri redirectUri) + { + if (redirectUri.Scheme is "http" or "https") + { + return redirectUri.IsLoopback ? "native" : "web"; + } + return "native"; + } + private static string? GetResourceUri(ProtectedResourceMetadata protectedResourceMetadata) => protectedResourceMetadata.Resource; + private string? ComputeEffectiveScope( + ProtectedResourceMetadata protectedResourceMetadata, + AuthorizationServerMetadata authServerMetadata) + { + var scope = GetScopeParameter(protectedResourceMetadata); + scope = AugmentScopeWithOfflineAccess(scope, authServerMetadata); + if (_scopeSelector is not null) + { + var selected = _scopeSelector(scope?.Split(' ')); + scope = selected is not null ? string.Join(" ", selected) : null; + } + return scope; + } + private string? GetScopeParameter(ProtectedResourceMetadata protectedResourceMetadata) + { + // Determine the scopes for the current operation from the challenge or metadata. + var currentOperationScopes = GetCurrentOperationScopes(protectedResourceMetadata); + + if (currentOperationScopes.Count == 0) + { + // If we have previously requested scopes but nothing new, return the accumulated set. + return _accumulatedScopes.Count > 0 + ? string.Join(" ", _accumulatedScopes.OrderBy(s => s, StringComparer.Ordinal)) + : null; + } + + // Per SEP-2350: Compute the union of previously requested scopes and newly challenged scopes + // to avoid losing permissions needed for other operations during step-up authorization. + // Note: the accumulator stores only server-challenged / scopes_supported / configured scopes. + // offline_access (AugmentScopeWithOfflineAccess) and any ScopeSelector are applied per request + // in ComputeEffectiveScope and are intentionally not accumulated, so the selector always sees + // the full union and the operation stays idempotent. + foreach (var scope in currentOperationScopes) + { + _accumulatedScopes.Add(scope); + } + + // Sort scopes for stable, deterministic output (scopes are unordered per RFC 6749 §3.3). + return string.Join(" ", _accumulatedScopes.OrderBy(s => s, StringComparer.Ordinal)); + } + + /// + /// Determines the scopes required for the current operation, preferring the WWW-Authenticate + /// challenge scope, then scopes_supported from the protected resource metadata, then the + /// configured scopes. Returns the individual scope tokens so callers can compare and accumulate them + /// without re-joining and re-splitting. This does not mutate the accumulated scope set. + /// + private IReadOnlyList GetCurrentOperationScopes(ProtectedResourceMetadata protectedResourceMetadata) { if (!string.IsNullOrEmpty(protectedResourceMetadata.WwwAuthenticateScope)) { - return protectedResourceMetadata.WwwAuthenticateScope; + return SplitScopes(protectedResourceMetadata.WwwAuthenticateScope!); } - else if (protectedResourceMetadata.ScopesSupported.Count > 0) + + var scopesSupported = protectedResourceMetadata.ScopesSupported; + if (scopesSupported.Count > 0) { - return string.Join(" ", protectedResourceMetadata.ScopesSupported); + // scopes_supported is already a list of individual scopes; avoid join/split round-tripping. + return scopesSupported as IReadOnlyList ?? [.. scopesSupported]; } - return _configuredScopes; + return _configuredScopes is null ? [] : SplitScopes(_configuredScopes); } + private static string[] SplitScopes(string scopes) => + scopes.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); + /// - /// Verifies that the resource URI in the metadata exactly matches the original request URL as required by the RFC. - /// Per RFC: The resource value must be identical to the URL that the client used to make the request to the resource server. + /// Returns if the current challenge requires at least one scope that has not + /// already been requested in a previous (re-)authorization. The caller combines this with step-up + /// attempt tracking: per SEP-2350, a step-up that adds a new scope is always allowed, but once a + /// step-up has been attempted, a later challenge that adds no new scope is treated as a permanent + /// failure because re-running interactive authorization cannot make progress. + /// + private bool ChallengeIntroducesNewScopes(ProtectedResourceMetadata protectedResourceMetadata) + { + var currentOperationScopes = GetCurrentOperationScopes(protectedResourceMetadata); + if (currentOperationScopes.Count == 0) + { + // No concrete scope to request, so a re-authorization cannot add anything new. + return false; + } + + foreach (var scope in currentOperationScopes) + { + if (!_accumulatedScopes.Contains(scope)) + { + return true; + } + } + + return false; + } + + /// + /// Augments the scope parameter with offline_access if the authorization server advertises it in + /// scopes_supported and it is not already present. This signals to OIDC-flavored authorization servers + /// that the client desires a refresh token, per SEP-2207. + /// + private static string? AugmentScopeWithOfflineAccess(string? scope, AuthorizationServerMetadata authServerMetadata) + { + const string OfflineAccess = "offline_access"; + + if (authServerMetadata.ScopesSupported?.Contains(OfflineAccess) is not true) + { + return scope; + } + + if (scope is null) + { + return OfflineAccess; + } + + // Check if offline_access is already in the scope string (space-separated tokens). + foreach (var token in scope.Split(' ')) + { + if (token == OfflineAccess) + { + return scope; + } + } + + return scope + " " + OfflineAccess; + } + + /// + /// Validates that an authorization response is bound to the transaction that initiated it. + /// + /// The state returned in the authorization response. + /// The state sent in the authorization request. + private static void ValidateStateResponse(string? state, string expectedState) + { + if (string.IsNullOrEmpty(state)) + { + ThrowFailedToHandleUnauthorizedResponse( + "The authorization response did not include the required state parameter."); + } + + if (!string.Equals(state, expectedState, StringComparison.Ordinal)) + { + ThrowFailedToHandleUnauthorizedResponse( + "The authorization response state did not match the state sent in the authorization request."); + } + } + + /// + /// Validates the iss parameter from an authorization response per + /// RFC 9207. + /// + /// The issuer identifier received in the authorization response, or null if absent. + /// The authorization server metadata containing the expected issuer. + private void ValidateIssuerResponse(string? iss, AuthorizationServerMetadata authServerMetadata) + { + var expectedIssuer = authServerMetadata.Issuer?.OriginalString; + + if ((authServerMetadata.AuthorizationResponseIssParameterSupported || !string.IsNullOrEmpty(iss)) && + expectedIssuer is null) + { + ThrowFailedToHandleUnauthorizedResponse( + "Authorization server metadata did not provide an issuer required to validate the authorization response."); + } + + if (authServerMetadata.AuthorizationResponseIssParameterSupported) + { + // Server advertises iss support: iss MUST be present and match. + if (string.IsNullOrEmpty(iss)) + { + ThrowFailedToHandleUnauthorizedResponse( + "Authorization server advertises RFC 9207 iss parameter support but none was received in the authorization response."); + } + + // Use exact string comparison per RFC 9207 / RFC 3986 §6.2.1. + if (!string.Equals(iss, expectedIssuer, StringComparison.Ordinal)) + { + ThrowFailedToHandleUnauthorizedResponse( + $"Authorization response issuer '{iss}' does not match expected issuer '{expectedIssuer}'."); + } + } + else + { + // Server does not advertise iss support: if iss is present, still validate it. + // RFC 9207 cannot protect against a server that neither advertises support nor + // returns an iss parameter, so an absent iss is accepted in that case. + if (!string.IsNullOrEmpty(iss)) + { + if (!string.Equals(iss, expectedIssuer, StringComparison.Ordinal)) + { + ThrowFailedToHandleUnauthorizedResponse( + $"Authorization response issuer '{iss}' does not match expected issuer '{expectedIssuer}'."); + } + } + // If iss is absent and not advertised, proceed normally. + } + } + + /// + /// Verifies that the resource URI in the metadata matches the original request URL. + /// Accepts either an exact match with the full request URL, or a match with the base URL + /// (authority only, path discarded) as allowed by the MCP spec, which derives the authorization + /// base URL by discarding the path component from the MCP server URL. /// /// The metadata to verify. /// /// The original URL the client used to make the request to the resource server or the root Uri for the resource server /// if the metadata was automatically requested from the root well-known location. /// - /// True if the resource URI exactly matches the original request URL, otherwise false. + /// + /// True if the resource URI exactly matches the original request URL or its authority-level base URL, otherwise false. + /// private static bool VerifyResourceMatch(ProtectedResourceMetadata protectedResourceMetadata, Uri resourceLocation) { if (protectedResourceMetadata.Resource is null) @@ -743,14 +1228,22 @@ private static bool VerifyResourceMatch(ProtectedResourceMetadata protectedResou return false; } - // Per RFC: The resource value must be identical to the URL that the client used - // to make the request to the resource server. Compare entire URIs, not just the host. - // Normalize the URIs to ensure consistent comparison string normalizedMetadataResource = NormalizeUri(protectedResourceMetadata.Resource); string normalizedResourceLocation = NormalizeUri(resourceLocation); - return string.Equals(normalizedMetadataResource, normalizedResourceLocation, StringComparison.OrdinalIgnoreCase); + // Accept exact match with the full MCP endpoint URI + if (string.Equals(normalizedMetadataResource, normalizedResourceLocation, StringComparison.OrdinalIgnoreCase)) + { + return true; + } + + // Per the MCP spec's "Canonical Server URI" section, both the path-specific URI (e.g. https://mcp.example.com/mcp) + // and the authority-only URI (e.g. https://mcp.example.com) are valid canonical URIs for identifying an MCP server. + // Accept a match with the base URL (authority only, path discarded) to support servers that use the less specific form. + + string normalizedBaseUrl = NormalizeUri(new Uri(resourceLocation.GetLeftPart(UriPartial.Authority))); + return string.Equals(normalizedMetadataResource, normalizedBaseUrl, StringComparison.OrdinalIgnoreCase); } /// @@ -869,7 +1362,8 @@ private async Task ExtractProtectedResourceMetadata(H // https://modelcontextprotocol.io/specification/2025-11-25/basic/authorization#protected-resource-metadata-discovery-requirements metadata.WwwAuthenticateScope = wwwAuthenticateScope; - // Per RFC: The resource value must be identical to the URL that the client used to make the request to the resource server + // Validate that the resource URI in metadata corresponds to the server we're connecting to. + // VerifyResourceMatch accepts both an exact URI match and an authority-level (base URL) match per the MCP spec. LogValidatingResourceMetadata(resourceUri); if (!isLegacyFallback && !VerifyResourceMatch(metadata, resourceUri)) @@ -934,7 +1428,7 @@ private async Task ExtractProtectedResourceMetadata(H yield return (new Uri($"{hostBase}{ProtectedResourceMetadataWellKnownPath}"), new Uri(hostBase)); } - private static string GenerateCodeVerifier() + private static string GenerateRandomBase64UrlValue() { #if NET9_0_OR_GREATER Span bytes = stackalloc byte[32]; @@ -973,6 +1467,98 @@ private static string ToBase64UrlString(byte[] bytes) private string GetClientIdOrThrow() => _clientId ?? throw new InvalidOperationException("Client ID is not available. This may indicate an issue with dynamic client registration."); + /// + /// Restores the client registration persisted alongside cached tokens when this provider has not been + /// assigned a client ID yet. This allows a durable to use a refresh token that + /// survived a process restart without re-running dynamic client registration. Credentials are restored + /// only when the cache binds them to the currently selected authorization server. An explicitly configured + /// client ID always takes precedence, so nothing is restored when one is already available. + /// + /// + /// Callers must hold _tokenAcquisitionLock: this writes the shared _clientId, + /// _clientSecret, and _tokenEndpointAuthMethod fields, which the lock serializes. + /// A single cache still stores only one registration, but the persisted authorization-server issuer + /// prevents that registration from being reused with a different server. + /// + private void RestoreCachedClientCredentials(TokenContainer? tokens, Uri selectedAuthServer) + { + if (tokens is null) + { + return; + } + + // The guard above guarantees a non-null container, but older nullable flow analysis on + // netstandard2.0/net472 may not preserve that narrowing, so capture a non-null local. + var cached = tokens!; + + if (_configuredClientId is not null) + { + if (!string.Equals(cached.ClientId, _configuredClientId, StringComparison.Ordinal)) + { + return; + } + + // Restore the issuer binding independently from the secret. A rotated configured secret + // must not make credentials previously bound to another issuer appear portable. + _clientCredentialsAuthorizationServer = cached.AuthorizationServer; + + if (string.Equals(cached.AuthorizationServer, selectedAuthServer.OriginalString, StringComparison.Ordinal) && + string.Equals(cached.ClientSecret, _clientSecret, StringComparison.Ordinal)) + { + _tokenEndpointAuthMethod ??= cached.TokenEndpointAuthMethod; + } + + return; + } + + if (!string.IsNullOrEmpty(_clientId)) + { + return; + } + + if (string.IsNullOrEmpty(cached.ClientId) || + !string.Equals(cached.AuthorizationServer, selectedAuthServer.OriginalString, StringComparison.Ordinal)) + { + return; + } + + // Assign _clientId last. Callers treat a non-empty _clientId as "registration complete", so the + // secret and auth method must already be in place before _clientId becomes observable. + _clientSecret ??= cached.ClientSecret; + _tokenEndpointAuthMethod ??= cached.TokenEndpointAuthMethod; + _clientId = cached.ClientId; + _clientCredentialsAuthorizationServer = cached.AuthorizationServer; + } + + private bool CachedTokensMatchClientCredentials(TokenContainer? tokens, string? authorizationServer) => + tokens is not null && + string.Equals(tokens.AuthorizationServer, authorizationServer, StringComparison.Ordinal) && + string.Equals(tokens.ClientId, _clientId, StringComparison.Ordinal) && + string.Equals(tokens.ClientSecret, _clientSecret, StringComparison.Ordinal) && + string.Equals(tokens.TokenEndpointAuthMethod, _tokenEndpointAuthMethod, StringComparison.Ordinal); + + private void BindClientCredentialsToAuthorizationServer(Uri selectedAuthServer) + { + if (_clientCredentialsAuthorizationServer is null || + string.Equals(_clientCredentialsAuthorizationServer, selectedAuthServer.OriginalString, StringComparison.Ordinal)) + { + return; + } + + if (_configuredClientId is not null) + { + ThrowFailedToHandleUnauthorizedResponse( + $"The authorization server changed from '{_clientCredentialsAuthorizationServer}' to '{selectedAuthServer.OriginalString}', " + + "but explicitly configured client credentials cannot be assumed to be valid for the new authorization server."); + } + + _clientId = null; + _clientSecret = null; + _tokenEndpointAuthMethod = null; + _authServerMetadata = null; + _clientCredentialsAuthorizationServer = null; + } + [DoesNotReturn] private static void ThrowFailedToHandleUnauthorizedResponse(string message) => throw new McpException($"Failed to handle unauthorized response with 'Bearer' scheme. {message}"); @@ -989,6 +1575,9 @@ private static void ThrowFailedToHandleUnauthorizedResponse(string message) => [LoggerMessage(Level = LogLevel.Error, Message = "Error fetching auth server metadata from {Endpoint}")] partial void LogErrorFetchingAuthServerMetadata(Exception ex, Uri endpoint); + [LoggerMessage(Level = LogLevel.Warning, Message = "Authorization server metadata from {Endpoint} does not satisfy PKCE requirements; skipping it and trying the next discovery endpoint.")] + partial void LogAuthServerMetadataMissingPkceSupport(Exception ex, Uri endpoint); + [LoggerMessage(Level = LogLevel.Information, Message = "Performing dynamic client registration with {RegistrationEndpoint}")] partial void LogPerformingDynamicClientRegistration(Uri registrationEndpoint); diff --git a/src/ModelContextProtocol.Core/Authentication/DynamicClientRegistrationOptions.cs b/src/ModelContextProtocol.Core/Authentication/DynamicClientRegistrationOptions.cs index 5d145a568..88db6bd45 100644 --- a/src/ModelContextProtocol.Core/Authentication/DynamicClientRegistrationOptions.cs +++ b/src/ModelContextProtocol.Core/Authentication/DynamicClientRegistrationOptions.cs @@ -34,6 +34,24 @@ public sealed class DynamicClientRegistrationOptions /// public string? InitialAccessToken { get; set; } + /// + /// Gets or sets the OIDC application_type sent during dynamic client registration. + /// + /// + /// + /// When , the SDK infers the value from the configured + /// : loopback hosts (localhost, + /// 127.0.0.1, [::1]) and custom-scheme URIs map to "native"; remote + /// http:// and https:// URIs map to "web". + /// + /// + /// When set explicitly, the value is sent without modification. Use this to account for + /// authorization-server-specific requirements or to retry a registration with an adjusted + /// application type. + /// + /// + public string? ApplicationType { get; set; } + /// /// Gets or sets the delegate used for handling the dynamic client registration response. /// diff --git a/src/ModelContextProtocol.Core/Authentication/DynamicClientRegistrationRequest.cs b/src/ModelContextProtocol.Core/Authentication/DynamicClientRegistrationRequest.cs index 8496610e7..6ad8bf2c1 100644 --- a/src/ModelContextProtocol.Core/Authentication/DynamicClientRegistrationRequest.cs +++ b/src/ModelContextProtocol.Core/Authentication/DynamicClientRegistrationRequest.cs @@ -48,4 +48,10 @@ internal sealed class DynamicClientRegistrationRequest /// [JsonPropertyName("scope")] public string? Scope { get; init; } + + /// + /// Gets or sets the OIDC application type ("native" or "web") for the client. + /// + [JsonPropertyName("application_type")] + public string? ApplicationType { get; init; } } \ No newline at end of file diff --git a/src/ModelContextProtocol.Core/Authentication/ExchangeJwtBearerGrantOptions.cs b/src/ModelContextProtocol.Core/Authentication/ExchangeJwtBearerGrantOptions.cs new file mode 100644 index 000000000..e1a1df33f --- /dev/null +++ b/src/ModelContextProtocol.Core/Authentication/ExchangeJwtBearerGrantOptions.cs @@ -0,0 +1,37 @@ +namespace ModelContextProtocol.Authentication; + +/// +/// Options for exchanging a JWT Authorization Grant for an access token via RFC 7523. +/// +internal sealed class ExchangeJwtBearerGrantOptions +{ + /// + /// Gets or sets the MCP Server's authorization server token endpoint URL. + /// + public required string TokenEndpoint { get; set; } + + /// + /// Gets or sets the JWT Authorization Grant (JAG) assertion obtained from token exchange. + /// + public required string Assertion { get; set; } + + /// + /// Gets or sets the client ID for authentication with the MCP authorization server. + /// + public required string ClientId { get; set; } + + /// + /// Gets or sets the client secret for authentication with the MCP authorization server. Optional. + /// + public string? ClientSecret { get; set; } + + /// + /// Gets or sets the token endpoint authentication method. + /// + public string? TokenEndpointAuthMethod { get; set; } + + /// + /// Gets or sets the scopes to request (space-separated). Optional. + /// + public string? Scope { get; set; } +} diff --git a/src/ModelContextProtocol.Core/Authentication/ITokenCache.cs b/src/ModelContextProtocol.Core/Authentication/ITokenCache.cs index 3dc6e6351..62d57b913 100644 --- a/src/ModelContextProtocol.Core/Authentication/ITokenCache.cs +++ b/src/ModelContextProtocol.Core/Authentication/ITokenCache.cs @@ -3,6 +3,11 @@ namespace ModelContextProtocol.Authentication; /// /// Allows the client to cache access tokens beyond the lifetime of the transport. /// +/// +/// Implementations must be safe for concurrent use. A single cache instance may be shared by multiple +/// in-flight requests, and in particular can be invoked concurrently +/// (it is called on the request hot path without holding the provider's token-acquisition lock). +/// public interface ITokenCache { /// diff --git a/src/ModelContextProtocol.Core/Authentication/IdentityAssertionGrant.cs b/src/ModelContextProtocol.Core/Authentication/IdentityAssertionGrant.cs new file mode 100644 index 000000000..ecc5eb35d --- /dev/null +++ b/src/ModelContextProtocol.Core/Authentication/IdentityAssertionGrant.cs @@ -0,0 +1,302 @@ +using System.Net.Http.Headers; +using System.Text.Json; + +namespace ModelContextProtocol.Authentication; + +/// +/// Provides internal utilities for the Cross-Application Access authorization flow. +/// +/// +/// Implements the Enterprise Managed Authorization flow as specified at +/// . +/// +internal static class IdentityAssertionGrant +{ + #region Constants + + /// Grant type URN for RFC 8693 token exchange. + public const string GrantTypeTokenExchange = "urn:ietf:params:oauth:grant-type:token-exchange"; + + /// Grant type URN for RFC 7523 JWT Bearer authorization grant. + public const string GrantTypeJwtBearer = "urn:ietf:params:oauth:grant-type:jwt-bearer"; + + /// Token type URN for OpenID Connect ID Tokens (RFC 8693). + public const string TokenTypeIdToken = "urn:ietf:params:oauth:token-type:id_token"; + + /// Token type URN for SAML 2.0 assertions (RFC 8693). + public const string TokenTypeSaml2 = "urn:ietf:params:oauth:token-type:saml2"; + + /// + /// Token type URN for Identity Assertion JWT Authorization Grants. + /// As specified at + /// . + /// + public const string TokenTypeIdJag = "urn:ietf:params:oauth:token-type:id-jag"; + + /// + /// The expected value for token_type in a JAG token exchange response per RFC 8693 §2.2.1. + /// The issued token is not an OAuth access token, so its type is "N_A". + /// + public const string TokenTypeNotApplicable = "N_A"; + + #endregion + + #region Token Exchange (RFC 8693) + + /// + /// Requests a JWT Authorization Grant (JAG) from an Identity Provider via RFC 8693 Token Exchange. + /// Returns the JAG string to be used as a JWT Bearer assertion (RFC 7523) against the MCP authorization server. + /// + public static async Task RequestJwtAuthorizationGrantAsync( + RequestJwtAuthGrantOptions options, + HttpClient httpClient, + CancellationToken cancellationToken = default) + { + Throw.IfNull(options); + Throw.IfNullOrWhiteSpace(options.TokenEndpoint); + Throw.IfNullOrWhiteSpace(options.Audience); + Throw.IfNullOrWhiteSpace(options.Resource); + Throw.IfNullOrWhiteSpace(options.IdToken); + Throw.IfNullOrWhiteSpace(options.ClientId); + + var formData = new Dictionary + { + ["grant_type"] = GrantTypeTokenExchange, + ["requested_token_type"] = TokenTypeIdJag, + ["subject_token"] = options.IdToken, + ["subject_token_type"] = TokenTypeIdToken, + ["audience"] = options.Audience, + ["resource"] = options.Resource, + ["client_id"] = options.ClientId, + }; + + if (!string.IsNullOrEmpty(options.ClientSecret)) + { + formData["client_secret"] = options.ClientSecret!; + } + + if (!string.IsNullOrEmpty(options.Scope)) + { + formData["scope"] = options.Scope!; + } + + using var requestContent = new FormUrlEncodedContent(formData); + using var httpRequest = new HttpRequestMessage(HttpMethod.Post, options.TokenEndpoint) + { + Content = requestContent + }; + + httpRequest.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); + + using var httpResponse = await httpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false); + var responseBody = await httpResponse.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false); + + if (!httpResponse.IsSuccessStatusCode) + { + OAuthErrorResponse? errorResponse = null; + try + { + errorResponse = JsonSerializer.Deserialize(responseBody, McpJsonUtilities.JsonContext.Default.OAuthErrorResponse); + } + catch + { + // Could not parse error response + } + + throw new IdentityAssertionGrantException( + $"Token exchange failed with status {(int)httpResponse.StatusCode}.", + errorResponse?.Error, + errorResponse?.ErrorDescription, + errorResponse?.ErrorUri); + } + + var response = JsonSerializer.Deserialize(responseBody, McpJsonUtilities.JsonContext.Default.JagTokenExchangeResponse); + + if (response is null) + { + var ex = new IdentityAssertionGrantException("Failed to parse token exchange response."); + ex.Data["ResponseBody"] = responseBody; + throw ex; + } + + if (string.IsNullOrEmpty(response.AccessToken)) + { + throw new IdentityAssertionGrantException("Token exchange response missing required field: access_token"); + } + + if (!string.Equals(response.IssuedTokenType, TokenTypeIdJag, StringComparison.Ordinal)) + { + throw new IdentityAssertionGrantException( + $"Token exchange response issued_token_type must be '{TokenTypeIdJag}', got '{response.IssuedTokenType}'."); + } + + if (!string.Equals(response.TokenType, TokenTypeNotApplicable, StringComparison.Ordinal)) + { + throw new IdentityAssertionGrantException( + $"Token exchange response token_type must be '{TokenTypeNotApplicable}' per RFC 8693 §2.2.1, got '{response.TokenType}'."); + } + + return response.AccessToken; + } + + #endregion + + #region JWT Bearer Grant (RFC 7523) + + /// + /// Exchanges a JWT Authorization Grant (JAG) for an access token at an MCP Server's authorization server + /// using the JWT Bearer grant (RFC 7523). + /// + public static async Task ExchangeJwtBearerGrantAsync( + ExchangeJwtBearerGrantOptions options, + HttpClient httpClient, + CancellationToken cancellationToken = default) + { + Throw.IfNull(options); + Throw.IfNullOrWhiteSpace(options.TokenEndpoint); + Throw.IfNullOrWhiteSpace(options.Assertion); + Throw.IfNullOrWhiteSpace(options.ClientId); + + var formData = new Dictionary + { + ["grant_type"] = GrantTypeJwtBearer, + ["assertion"] = options.Assertion, + ["client_id"] = options.ClientId, + }; + + using var httpRequest = new HttpRequestMessage(HttpMethod.Post, options.TokenEndpoint); + + if (string.Equals(options.TokenEndpointAuthMethod, "client_secret_basic", StringComparison.Ordinal)) + { + formData.Remove("client_id"); + var credentials = $"{Uri.EscapeDataString(options.ClientId)}:{Uri.EscapeDataString(options.ClientSecret ?? string.Empty)}"; + httpRequest.Headers.Authorization = new AuthenticationHeaderValue( + "Basic", + Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(credentials))); + } + else if (string.Equals(options.TokenEndpointAuthMethod, "client_secret_post", StringComparison.Ordinal) && + !string.IsNullOrEmpty(options.ClientSecret)) + { + formData["client_secret"] = options.ClientSecret!; + } + + if (!string.IsNullOrEmpty(options.Scope)) + { + formData["scope"] = options.Scope!; + } + + httpRequest.Content = new FormUrlEncodedContent(formData); + httpRequest.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); + + using var httpResponse = await httpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false); + var responseBody = await httpResponse.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false); + + if (!httpResponse.IsSuccessStatusCode) + { + OAuthErrorResponse? errorResponse = null; + try + { + errorResponse = JsonSerializer.Deserialize(responseBody, McpJsonUtilities.JsonContext.Default.OAuthErrorResponse); + } + catch + { + // Could not parse error response + } + + throw new IdentityAssertionGrantException( + $"JWT bearer grant failed with status {(int)httpResponse.StatusCode}.", + errorResponse?.Error, + errorResponse?.ErrorDescription, + errorResponse?.ErrorUri); + } + + var response = JsonSerializer.Deserialize(responseBody, McpJsonUtilities.JsonContext.Default.JwtBearerAccessTokenResponse); + + if (response is null) + { + var ex = new IdentityAssertionGrantException("Failed to parse JWT bearer grant response."); + ex.Data["ResponseBody"] = responseBody; + throw ex; + } + + if (string.IsNullOrEmpty(response.AccessToken)) + { + throw new IdentityAssertionGrantException("JWT bearer grant response missing required field: access_token"); + } + + if (string.IsNullOrEmpty(response.TokenType)) + { + throw new IdentityAssertionGrantException("JWT bearer grant response missing required field: token_type"); + } + + if (!string.Equals(response.TokenType, "bearer", StringComparison.OrdinalIgnoreCase)) + { + throw new IdentityAssertionGrantException( + $"JWT bearer grant response token_type must be 'bearer' per RFC 7523, got '{response.TokenType}'."); + } + + return new TokenContainer + { + AccessToken = response.AccessToken, + TokenType = response.TokenType, + RefreshToken = response.RefreshToken, + ExpiresIn = response.ExpiresIn, + Scope = response.Scope, + ObtainedAt = DateTimeOffset.UtcNow, + }; + } + + #endregion + + #region Helper: Auth Server Metadata Discovery + + private static readonly string[] s_wellKnownPaths = [".well-known/openid-configuration", ".well-known/oauth-authorization-server"]; + + /// + /// Discovers authorization server metadata from the well-known endpoints. + /// + internal static async Task DiscoverAuthServerMetadataAsync( + Uri issuerUrl, + HttpClient httpClient, + CancellationToken cancellationToken) + { + var baseUrl = issuerUrl.ToString(); + if (!baseUrl.EndsWith("/", StringComparison.Ordinal)) + { + issuerUrl = new Uri($"{baseUrl}/"); + } + + foreach (var path in s_wellKnownPaths) + { + try + { + var wellKnownEndpoint = new Uri(issuerUrl, path); + var response = await httpClient.GetAsync(wellKnownEndpoint, cancellationToken).ConfigureAwait(false); + + if (!response.IsSuccessStatusCode) + { + continue; + } + + using var stream = await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false); + var metadata = await JsonSerializer.DeserializeAsync( + stream, + McpJsonUtilities.JsonContext.Default.AuthorizationServerMetadata, + cancellationToken).ConfigureAwait(false); + + if (metadata is not null) + { + return metadata; + } + } + catch + { + continue; + } + } + + throw new IdentityAssertionGrantException($"Failed to discover authorization server metadata for: {issuerUrl}"); + } + + #endregion +} diff --git a/src/ModelContextProtocol.Core/Authentication/IdentityAssertionGrantContext.cs b/src/ModelContextProtocol.Core/Authentication/IdentityAssertionGrantContext.cs new file mode 100644 index 000000000..2b956b9b9 --- /dev/null +++ b/src/ModelContextProtocol.Core/Authentication/IdentityAssertionGrantContext.cs @@ -0,0 +1,20 @@ +namespace ModelContextProtocol.Authentication; + +/// +/// Context provided to the for a Cross-Application Access +/// authorization flow. Contains the URLs discovered during the OAuth flow needed for the token exchange step. +/// +public sealed class IdentityAssertionGrantContext +{ + /// + /// Gets the MCP resource server URL (i.e., the resource parameter for token exchange). + /// This is the URL of the MCP server being accessed. + /// + public required Uri ResourceUrl { get; init; } + + /// + /// Gets the MCP authorization server URL (i.e., the audience parameter for token exchange). + /// This is the URL of the authorization server protecting the MCP resource. + /// + public required Uri AuthorizationServerUrl { get; init; } +} diff --git a/src/ModelContextProtocol.Core/Authentication/IdentityAssertionGrantException.cs b/src/ModelContextProtocol.Core/Authentication/IdentityAssertionGrantException.cs new file mode 100644 index 000000000..3dcec8082 --- /dev/null +++ b/src/ModelContextProtocol.Core/Authentication/IdentityAssertionGrantException.cs @@ -0,0 +1,51 @@ +namespace ModelContextProtocol.Authentication; + +/// +/// Represents an error that occurred during a Cross-Application Access authorization operation +/// (token exchange per RFC 8693, and JWT bearer grant per RFC 7523). +/// +public sealed class IdentityAssertionGrantException : Exception +{ + /// + /// Gets the OAuth error code, if available (e.g., "invalid_request", "invalid_grant"). + /// + public string? ErrorCode { get; } + + /// + /// Gets the human-readable error description from the OAuth error response. + /// + public string? ErrorDescription { get; } + + /// + /// Gets the URI identifying a human-readable web page with error information. + /// + public string? ErrorUri { get; } + + /// + /// Initializes a new instance of the class. + /// + /// The error message. + /// The OAuth error code. + /// The human-readable error description. + /// The error URI. + public IdentityAssertionGrantException(string message, string? errorCode = null, string? errorDescription = null, string? errorUri = null) + : base(FormatMessage(message, errorCode, errorDescription)) + { + ErrorCode = errorCode; + ErrorDescription = errorDescription; + ErrorUri = errorUri; + } + + private static string FormatMessage(string message, string? errorCode, string? errorDescription) + { + if (!string.IsNullOrEmpty(errorCode)) + { + message = $"{message} Error: {errorCode}"; + if (!string.IsNullOrEmpty(errorDescription)) + { + message = $"{message} ({errorDescription})"; + } + } + return message; + } +} diff --git a/src/ModelContextProtocol.Core/Authentication/IdentityAssertionGrantIdTokenCallback.cs b/src/ModelContextProtocol.Core/Authentication/IdentityAssertionGrantIdTokenCallback.cs new file mode 100644 index 000000000..2951d1e8b --- /dev/null +++ b/src/ModelContextProtocol.Core/Authentication/IdentityAssertionGrantIdTokenCallback.cs @@ -0,0 +1,17 @@ +namespace ModelContextProtocol.Authentication; + +/// +/// Represents a method that returns an OIDC ID token for use in a Cross-Application Access authorization flow. +/// +/// +/// Context containing the MCP resource and authorization server URLs discovered during the OAuth flow. +/// +/// The to monitor for cancellation requests. +/// +/// A task that represents the asynchronous operation. The task result contains the OIDC ID token string +/// obtained from the enterprise Identity Provider (e.g., via SSO login). The provider will then use this +/// ID token to perform the RFC 8693 token exchange to obtain a JWT Authorization Grant. +/// +public delegate Task IdentityAssertionGrantIdTokenCallback( + IdentityAssertionGrantContext context, + CancellationToken cancellationToken); diff --git a/src/ModelContextProtocol.Core/Authentication/IdentityAssertionGrantProvider.cs b/src/ModelContextProtocol.Core/Authentication/IdentityAssertionGrantProvider.cs new file mode 100644 index 000000000..41d2ea36d --- /dev/null +++ b/src/ModelContextProtocol.Core/Authentication/IdentityAssertionGrantProvider.cs @@ -0,0 +1,316 @@ +using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Logging.Abstractions; + +namespace ModelContextProtocol.Authentication; + +/// +/// Provides Cross-Application Access authorization as a standalone, non-interactive provider +/// that can be used alongside the MCP client's OAuth infrastructure. +/// +/// +/// +/// This provider implements the full Identity Assertion Authorization Grant flow as specified at +/// : +/// +/// +/// +/// The is called to obtain an OIDC ID token. +/// It receives a with the discovered resource and authorization +/// server URLs. +/// +/// +/// The provider performs the RFC 8693 token exchange at the enterprise Identity Provider +/// (using the configured IdpTokenEndpoint or discovered from IdpUrl), +/// exchanging the ID token for a JWT Authorization Grant (JAG). +/// +/// +/// The JAG is then exchanged for an access token at the MCP Server's authorization server +/// via the RFC 7523 JWT Bearer grant. +/// +/// +/// +/// Concurrency: a single provider instance may be shared across concurrent requests. Token +/// acquisition is coalesced through an internal lock, so if several callers observe an expired or +/// absent token at the same time, only one runs the exchange flow and the others await and reuse +/// its result. The cached token is refreshed at most once per expiry. +/// +/// +/// +/// +/// var provider = new IdentityAssertionGrantProvider( +/// new IdentityAssertionGrantProviderOptions +/// { +/// ClientId = "mcp-client-id", +/// IdpTokenEndpoint = "https://company.okta.com/oauth2/token", +/// IdpClientId = "idp-client-id", +/// IdTokenCallback = (context, ct) => +/// mySsoClient.GetIdTokenAsync(ct) +/// }, +/// httpClient: myHttpClient); +/// +/// var tokens = await provider.GetAccessTokenAsync( +/// resourceUrl: new Uri("https://mcp-server.example.com"), +/// authorizationServerUrl: new Uri("https://auth.example.com"), +/// cancellationToken: ct); +/// +/// +public sealed class IdentityAssertionGrantProvider +{ + private readonly IdentityAssertionGrantProviderOptions _options; + private readonly HttpClient _httpClient; + private readonly ILogger _logger; + + private TokenContainer? _cachedTokens; + + // Coalesces concurrent token acquisition so that when multiple in-flight requests observe an + // expired/absent token at the same time, only the first runs the exchange flow while the others + // await its result. Also serializes writes to _cachedTokens and _resolvedIdpTokenEndpoint. + // + // Intentionally not disposed: this instance is only ever used via WaitAsync/Wait/Release (never + // its AvailableWaitHandle), so SemaphoreSlim allocates no unmanaged resource and there is nothing + // to dispose. Do not access AvailableWaitHandle, or this field will need deterministic disposal. + private readonly SemaphoreSlim _tokenAcquisitionLock = new(1, 1); + + /// + /// Initializes a new instance of the class. + /// + /// Configuration for the Cross-Application Access provider. + /// + /// The HTTP client to use for token exchange requests. The caller is responsible for the lifetime of this instance. + /// + /// Optional logger factory. + /// or is null. + /// Required option values are missing. + public IdentityAssertionGrantProvider( + IdentityAssertionGrantProviderOptions options, + HttpClient httpClient, + ILoggerFactory? loggerFactory = null) + { + Throw.IfNull(options); + Throw.IfNull(httpClient); + + Throw.IfNullOrWhiteSpace(options.ClientId); + Throw.IfNullOrWhiteSpace(options.IdpClientId); + + if (string.IsNullOrEmpty(options.IdpUrl) && string.IsNullOrEmpty(options.IdpTokenEndpoint)) + { + throw new ArgumentException("Either IdpUrl or IdpTokenEndpoint is required.", $"{nameof(options)}.{nameof(options.IdpUrl)}"); + } + + if (options.IdTokenCallback is null) + { + throw new ArgumentNullException($"{nameof(options)}.{nameof(options.IdTokenCallback)}"); + } + + if (options.TokenEndpointAuthMethod is not null && + options.TokenEndpointAuthMethod is not ("client_secret_basic" or "client_secret_post" or "none")) + { + throw new ArgumentException( + $"{nameof(options.TokenEndpointAuthMethod)} must be 'client_secret_basic', 'client_secret_post', or 'none'.", + $"{nameof(options)}.{nameof(options.TokenEndpointAuthMethod)}"); + } + + if (options.TokenEndpointAuthMethod is "client_secret_basic" or "client_secret_post" && + string.IsNullOrEmpty(options.ClientSecret)) + { + throw new ArgumentException( + $"{nameof(options.ClientSecret)} is required when {nameof(options.TokenEndpointAuthMethod)} is '{options.TokenEndpointAuthMethod}'.", + $"{nameof(options)}.{nameof(options.ClientSecret)}"); + } + + _options = options; + _httpClient = httpClient; + _logger = (ILogger?)loggerFactory?.CreateLogger() ?? NullLogger.Instance; + } + + /// + /// Performs the full Cross-Application Access flow to obtain an access token for the given MCP resource. + /// + /// The MCP resource server URL. + /// The MCP authorization server URL. + /// The to monitor for cancellation requests. + /// A containing the access token. + /// Thrown when any step of the flow fails. + public async Task GetAccessTokenAsync( + Uri resourceUrl, + Uri authorizationServerUrl, + CancellationToken cancellationToken = default) + { + // Return cached token if still valid. Read the field once into a local so a concurrent + // InvalidateCache (which nulls _cachedTokens) cannot turn this lock-free check into a null + // dereference or a null return between the null check and the return. + var cachedBeforeLock = _cachedTokens; + if (cachedBeforeLock is not null && !cachedBeforeLock.IsExpired) + { + return cachedBeforeLock; + } + + // Serialize the exchange so concurrent callers that all saw the expired/absent token don't + // each run the full multi-step flow. Waiters re-check the cache after acquiring the lock and + // reuse the token produced by whoever ran the exchange first. + using var _ = await _tokenAcquisitionLock.LockAsync(cancellationToken).ConfigureAwait(false); + + if (_cachedTokens is not null && !_cachedTokens.IsExpired) + { + return _cachedTokens; + } + + return await AcquireAccessTokenAsync(resourceUrl, authorizationServerUrl, cancellationToken).ConfigureAwait(false); + } + + private async Task AcquireAccessTokenAsync( + Uri resourceUrl, + Uri authorizationServerUrl, + CancellationToken cancellationToken) + { + _logger.LogDebug("Starting Cross-Application Access flow for resource {ResourceUrl}", resourceUrl); + + // Step 1: Discover MCP authorization server metadata to find the token endpoint + var mcpAuthMetadata = await IdentityAssertionGrant.DiscoverAuthServerMetadataAsync( + authorizationServerUrl, _httpClient, cancellationToken).ConfigureAwait(false); + + var mcpTokenEndpoint = mcpAuthMetadata.TokenEndpoint?.ToString() + ?? throw new IdentityAssertionGrantException( + $"MCP authorization server metadata at {authorizationServerUrl} missing token_endpoint."); + + // Step 2: Call the ID token callback to get the caller's OIDC ID token + var context = new IdentityAssertionGrantContext + { + ResourceUrl = resourceUrl, + AuthorizationServerUrl = authorizationServerUrl, + }; + + _logger.LogDebug("Requesting ID token via callback"); + var idToken = await _options.IdTokenCallback(context, cancellationToken).ConfigureAwait(false); + + if (string.IsNullOrEmpty(idToken)) + { + throw new IdentityAssertionGrantException("ID token callback returned a null or empty token."); + } + + // Step 3: RFC 8693 token exchange — ID token → JWT Authorization Grant (JAG) at the enterprise IdP + _logger.LogDebug("Performing RFC 8693 token exchange at IdP"); + var idpTokenEndpoint = await ResolveIdpTokenEndpointAsync(cancellationToken).ConfigureAwait(false); + + var jag = await IdentityAssertionGrant.RequestJwtAuthorizationGrantAsync( + new RequestJwtAuthGrantOptions + { + TokenEndpoint = idpTokenEndpoint, + Audience = authorizationServerUrl.ToString(), + Resource = resourceUrl.ToString(), + IdToken = idToken, + ClientId = _options.IdpClientId, + ClientSecret = _options.IdpClientSecret, + Scope = _options.IdpScope, + }, _httpClient, cancellationToken).ConfigureAwait(false); + + // Step 4: RFC 7523 JWT bearer grant — JAG → access token at the MCP authorization server + _logger.LogDebug("Exchanging JAG for access token at {McpTokenEndpoint}", mcpTokenEndpoint); + var tokens = await IdentityAssertionGrant.ExchangeJwtBearerGrantAsync( + new ExchangeJwtBearerGrantOptions + { + TokenEndpoint = mcpTokenEndpoint, + Assertion = jag, + ClientId = _options.ClientId, + ClientSecret = _options.ClientSecret, + TokenEndpointAuthMethod = SelectTokenEndpointAuthMethod(mcpAuthMetadata), + Scope = _options.Scope, + }, _httpClient, cancellationToken).ConfigureAwait(false); + + _cachedTokens = tokens; + _logger.LogDebug("Cross-Application Access flow completed successfully"); + + return tokens; + } + + private string SelectTokenEndpointAuthMethod(AuthorizationServerMetadata metadata) + { + var supportedMethods = metadata.TokenEndpointAuthMethodsSupported; + if (_options.TokenEndpointAuthMethod is { } configuredMethod) + { + if (supportedMethods is { Count: > 0 } && + !supportedMethods.Contains(configuredMethod, StringComparer.Ordinal)) + { + throw new IdentityAssertionGrantException( + $"The configured token endpoint authentication method '{configuredMethod}' is not advertised by the MCP authorization server."); + } + + return configuredMethod; + } + + if (string.IsNullOrEmpty(_options.ClientSecret)) + { + if (supportedMethods is null or { Count: 0 } || + supportedMethods.Contains("none", StringComparer.Ordinal)) + { + return "none"; + } + + throw new IdentityAssertionGrantException( + "The MCP authorization server does not advertise a token endpoint authentication method usable without a client secret."); + } + + // Preserve the provider's existing client_secret_post behavior when it is available. + // RFC 8414 defines this metadata as a list of supported methods, not a preference order. + if (supportedMethods is null or { Count: 0 } || + supportedMethods.Contains("client_secret_post", StringComparer.Ordinal)) + { + return "client_secret_post"; + } + + if (supportedMethods.Contains("client_secret_basic", StringComparer.Ordinal)) + { + return "client_secret_basic"; + } + + throw new IdentityAssertionGrantException( + "The MCP authorization server does not advertise a supported token endpoint authentication method."); + } + + /// + /// Clears any cached tokens, forcing a fresh token exchange on the next call to . + /// + /// + /// This blocks until any token acquisition that is currently in progress completes, so that the + /// invalidation is not silently overwritten by a concurrent exchange storing a freshly obtained token. + /// + public void InvalidateCache() + { + _tokenAcquisitionLock.Wait(); + try + { + _cachedTokens = null; + } + finally + { + _tokenAcquisitionLock.Release(); + } + } + + private string? _resolvedIdpTokenEndpoint; + + private async Task ResolveIdpTokenEndpointAsync(CancellationToken cancellationToken) + { + if (_resolvedIdpTokenEndpoint is not null) + { + return _resolvedIdpTokenEndpoint; + } + + if (!string.IsNullOrEmpty(_options.IdpTokenEndpoint)) + { + _resolvedIdpTokenEndpoint = _options.IdpTokenEndpoint!; + return _resolvedIdpTokenEndpoint; + } + + // Discover from IdpUrl + var idpMetadata = await IdentityAssertionGrant.DiscoverAuthServerMetadataAsync( + new Uri(_options.IdpUrl!), _httpClient, cancellationToken).ConfigureAwait(false); + + var resolved = idpMetadata.TokenEndpoint?.ToString() + ?? throw new IdentityAssertionGrantException( + $"IdP metadata discovery for {_options.IdpUrl} did not return a token_endpoint."); + + _resolvedIdpTokenEndpoint = resolved; + return resolved; + } +} diff --git a/src/ModelContextProtocol.Core/Authentication/IdentityAssertionGrantProviderOptions.cs b/src/ModelContextProtocol.Core/Authentication/IdentityAssertionGrantProviderOptions.cs new file mode 100644 index 000000000..ecbd0551e --- /dev/null +++ b/src/ModelContextProtocol.Core/Authentication/IdentityAssertionGrantProviderOptions.cs @@ -0,0 +1,79 @@ +namespace ModelContextProtocol.Authentication; + +/// +/// Configuration options for the . +/// +public sealed class IdentityAssertionGrantProviderOptions +{ + /// + /// Gets or sets the MCP client ID used for the JWT Bearer grant (RFC 7523) at the MCP authorization server. + /// + public required string ClientId { get; set; } + + /// + /// Gets or sets the MCP client secret used for the JWT Bearer grant at the MCP authorization server. + /// Optional; only required if the MCP authorization server requires client authentication. + /// + public string? ClientSecret { get; set; } + + /// + /// Gets or sets the authentication method used at the MCP authorization server's token endpoint. + /// + /// + /// Supported values are client_secret_basic, client_secret_post, and none. + /// Set this to the method assigned to the pre-registered MCP client. When omitted, the provider + /// preserves its existing client_secret_post behavior when supported, then falls back to + /// another compatible method advertised by the authorization server. + /// + public string? TokenEndpointAuthMethod { get; set; } + + /// + /// Gets or sets the scopes to request from the MCP authorization server (space-separated). Optional. + /// + public string? Scope { get; set; } + + /// + /// Gets or sets the enterprise Identity Provider base URL for OAuth/OIDC metadata discovery. + /// Used to discover IdpTokenEndpoint automatically when is not set. + /// Either this or must be provided. + /// + public string? IdpUrl { get; set; } + + /// + /// Gets or sets the enterprise Identity Provider token endpoint URL for RFC 8693 token exchange. + /// When provided, skips IdP metadata discovery. Either this or must be provided. + /// + public string? IdpTokenEndpoint { get; set; } + + /// + /// Gets or sets the client ID for authentication with the enterprise Identity Provider (RFC 8693 token exchange). + /// + public required string IdpClientId { get; set; } + + /// + /// Gets or sets the client secret for authentication with the enterprise Identity Provider. Optional. + /// + public string? IdpClientSecret { get; set; } + + /// + /// Gets or sets the scopes to request from the enterprise Identity Provider (space-separated). Optional. + /// + public string? IdpScope { get; set; } + + /// + /// Gets or sets the callback that supplies the OIDC ID token for the Cross-Application Access flow. + /// + /// + /// + /// This callback is invoked after the MCP resource and authorization server URLs have been discovered. + /// It receives a with these URLs and should return the + /// OIDC ID token string obtained from the enterprise Identity Provider (e.g., from an SSO login session). + /// + /// + /// The provider will use the returned ID token to internally perform the RFC 8693 token exchange at the + /// configured IdP, obtaining a JWT Authorization Grant, which is then exchanged for an access token at + /// the MCP authorization server via RFC 7523. + /// + /// + public required IdentityAssertionGrantIdTokenCallback IdTokenCallback { get; set; } +} diff --git a/src/ModelContextProtocol.Core/Authentication/JagTokenExchangeResponse.cs b/src/ModelContextProtocol.Core/Authentication/JagTokenExchangeResponse.cs new file mode 100644 index 000000000..35a08f646 --- /dev/null +++ b/src/ModelContextProtocol.Core/Authentication/JagTokenExchangeResponse.cs @@ -0,0 +1,40 @@ +namespace ModelContextProtocol.Authentication; + +/// +/// Represents the response from an RFC 8693 Token Exchange for the JAG flow. +/// Contains the JWT Authorization Grant in the field. +/// +internal sealed class JagTokenExchangeResponse +{ + /// + /// Gets or sets the issued JAG. Despite the name "access_token" (required by RFC 8693), + /// this contains a JAG JWT, not an OAuth access token. + /// + [System.Text.Json.Serialization.JsonPropertyName("access_token")] + public string AccessToken { get; set; } = null!; + + /// + /// Gets or sets the type of the security token issued. + /// This MUST be . + /// + [System.Text.Json.Serialization.JsonPropertyName("issued_token_type")] + public string IssuedTokenType { get; set; } = null!; + + /// + /// Gets or sets the token type. This MUST be "N_A" per RFC 8693 §2.2.1. + /// + [System.Text.Json.Serialization.JsonPropertyName("token_type")] + public string TokenType { get; set; } = null!; + + /// + /// Gets or sets the scope of the issued token, if different from the request. + /// + [System.Text.Json.Serialization.JsonPropertyName("scope")] + public string? Scope { get; set; } + + /// + /// Gets or sets the lifetime in seconds of the issued token. + /// + [System.Text.Json.Serialization.JsonPropertyName("expires_in")] + public int? ExpiresIn { get; set; } +} diff --git a/src/ModelContextProtocol.Core/Authentication/JwtBearerAccessTokenResponse.cs b/src/ModelContextProtocol.Core/Authentication/JwtBearerAccessTokenResponse.cs new file mode 100644 index 000000000..9a0a4004e --- /dev/null +++ b/src/ModelContextProtocol.Core/Authentication/JwtBearerAccessTokenResponse.cs @@ -0,0 +1,37 @@ +namespace ModelContextProtocol.Authentication; + +/// +/// Represents the response from a JWT Bearer grant (RFC 7523) access token request. +/// +internal sealed class JwtBearerAccessTokenResponse +{ + /// + /// Gets or sets the OAuth access token. + /// + [System.Text.Json.Serialization.JsonPropertyName("access_token")] + public string AccessToken { get; set; } = null!; + + /// + /// Gets or sets the token type. This should be "Bearer". + /// + [System.Text.Json.Serialization.JsonPropertyName("token_type")] + public string TokenType { get; set; } = null!; + + /// + /// Gets or sets the lifetime in seconds of the access token. + /// + [System.Text.Json.Serialization.JsonPropertyName("expires_in")] + public int? ExpiresIn { get; set; } + + /// + /// Gets or sets the refresh token. + /// + [System.Text.Json.Serialization.JsonPropertyName("refresh_token")] + public string? RefreshToken { get; set; } + + /// + /// Gets or sets the scope of the access token. + /// + [System.Text.Json.Serialization.JsonPropertyName("scope")] + public string? Scope { get; set; } +} diff --git a/src/ModelContextProtocol.Core/Authentication/OAuthErrorResponse.cs b/src/ModelContextProtocol.Core/Authentication/OAuthErrorResponse.cs new file mode 100644 index 000000000..a8822fa32 --- /dev/null +++ b/src/ModelContextProtocol.Core/Authentication/OAuthErrorResponse.cs @@ -0,0 +1,26 @@ +namespace ModelContextProtocol.Authentication; + +/// +/// Represents an OAuth error response per RFC 6749 Section 5.2. +/// Used for both token exchange and JWT bearer grant error responses. +/// +internal sealed class OAuthErrorResponse +{ + /// + /// Gets or sets the error code. + /// + [System.Text.Json.Serialization.JsonPropertyName("error")] + public string? Error { get; set; } + + /// + /// Gets or sets the human-readable error description. + /// + [System.Text.Json.Serialization.JsonPropertyName("error_description")] + public string? ErrorDescription { get; set; } + + /// + /// Gets or sets the URI identifying a human-readable web page with error information. + /// + [System.Text.Json.Serialization.JsonPropertyName("error_uri")] + public string? ErrorUri { get; set; } +} diff --git a/src/ModelContextProtocol.Core/Authentication/ProtectedResourceMetadata.cs b/src/ModelContextProtocol.Core/Authentication/ProtectedResourceMetadata.cs index b6204fdf5..4b0a9ebe6 100644 --- a/src/ModelContextProtocol.Core/Authentication/ProtectedResourceMetadata.cs +++ b/src/ModelContextProtocol.Core/Authentication/ProtectedResourceMetadata.cs @@ -190,7 +190,8 @@ public sealed class ProtectedResourceMetadata /// The scopes included in the WWW-Authenticate challenge MAY match scopes_supported, be a subset or superset of it, /// or an alternative collection that is neither a strict subset nor superset. Clients MUST NOT assume any particular /// set relationship between the challenged scope set and scopes_supported. Clients MUST treat the scopes provided - /// in the challenge as authoritative for satisfying the current request. + /// in the challenge as authoritative for the current operation. When re-authorizing, clients SHOULD include these + /// scopes alongside any previously granted scopes to avoid losing permissions needed for other operations (SEP-2350). /// /// https://modelcontextprotocol.io/specification/2025-11-25/basic/authorization#protected-resource-metadata-discovery-requirements /// diff --git a/src/ModelContextProtocol.Core/Authentication/RequestJwtAuthGrantOptions.cs b/src/ModelContextProtocol.Core/Authentication/RequestJwtAuthGrantOptions.cs new file mode 100644 index 000000000..7e83b198d --- /dev/null +++ b/src/ModelContextProtocol.Core/Authentication/RequestJwtAuthGrantOptions.cs @@ -0,0 +1,42 @@ +namespace ModelContextProtocol.Authentication; + +/// +/// Options for requesting a JWT Authorization Grant from an Identity Provider via RFC 8693 Token Exchange. +/// +internal sealed class RequestJwtAuthGrantOptions +{ + /// + /// Gets or sets the IDP's token endpoint URL. + /// + public required string TokenEndpoint { get; set; } + + /// + /// Gets or sets the MCP authorization server URL (used as the audience parameter). + /// + public required string Audience { get; set; } + + /// + /// Gets or sets the MCP resource server URL (used as the resource parameter). + /// + public required string Resource { get; set; } + + /// + /// Gets or sets the OIDC ID token to exchange. + /// + public required string IdToken { get; set; } + + /// + /// Gets or sets the client ID for authentication with the IDP. + /// + public required string ClientId { get; set; } + + /// + /// Gets or sets the client secret for authentication with the IDP. Optional. + /// + public string? ClientSecret { get; set; } + + /// + /// Gets or sets the scopes to request (space-separated). Optional. + /// + public string? Scope { get; set; } +} diff --git a/src/ModelContextProtocol.Core/Authentication/ScopeSelectorDelegate.cs b/src/ModelContextProtocol.Core/Authentication/ScopeSelectorDelegate.cs new file mode 100644 index 000000000..5fe688ede --- /dev/null +++ b/src/ModelContextProtocol.Core/Authentication/ScopeSelectorDelegate.cs @@ -0,0 +1,37 @@ + +namespace ModelContextProtocol.Authentication; + +/// +/// Represents a method that selects or filters the OAuth scopes to request during authorization. +/// +/// +/// The scopes determined by the MCP scope selection strategy (WWW-Authenticate header scope → +/// scopes_supported from Protected Resource Metadata → +/// fallback), with offline_access appended when advertised by the authorization server. May be +/// if the server provided no scope information and no fallback scopes are configured. +/// +/// +/// The scopes to include in the authorization and Dynamic Client Registration requests. Return +/// or an empty enumerable to omit the scope parameter entirely. +/// +/// +/// +/// Use this delegate to filter or customize the proposed scopes before the authorization request is made. +/// Common scenarios include: +/// +/// +/// Requesting only a subset of the scopes offered by the server. +/// Appending a custom scope not advertised in the server metadata. +/// +/// +/// The MCP specification defines the following scope selection priority (highest to lowest): +/// WWW-Authenticate header scope → PRM scopes_supported → omit scope parameter. The +/// parameter already reflects this priority. The delegate runs after +/// offline_access has been auto-appended, so it can also remove that scope if desired. +/// +/// +/// The resolved scope is applied consistently to both the authorization URL and the Dynamic Client +/// Registration (DCR) request, so the registered client scope matches what is actually requested. +/// +/// +public delegate IEnumerable? ScopeSelectorDelegate(IReadOnlyCollection? scope); diff --git a/src/ModelContextProtocol.Core/Authentication/TokenContainer.cs b/src/ModelContextProtocol.Core/Authentication/TokenContainer.cs index 8126137f8..68d4fb85d 100644 --- a/src/ModelContextProtocol.Core/Authentication/TokenContainer.cs +++ b/src/ModelContextProtocol.Core/Authentication/TokenContainer.cs @@ -35,5 +35,56 @@ public sealed class TokenContainer /// public required DateTimeOffset ObtainedAt { get; set; } + /// + /// Gets or sets the OAuth client ID that these tokens were issued to. + /// + /// + /// This is persisted alongside the tokens so that a durable can survive a + /// process restart: on a cold start the client ID is restored from the cache, allowing a persisted + /// to be used without re-running dynamic client registration or prompting + /// the user to re-authorize. It reflects the client ID currently in use, whether that was obtained via + /// dynamic client registration, a client-id metadata document, or configured explicitly. On a cold + /// start it is only restored when no client ID has been configured, so an explicitly configured client + /// ID always takes precedence. + /// + public string? ClientId { get; set; } + + /// + /// Gets or sets the OAuth client secret that these tokens were issued to, if any. + /// + /// + /// This is persisted alongside so a durable can use a + /// persisted after a restart. It is only populated when a client secret was + /// issued (for example via dynamic client registration). + /// + /// Security: persisting this means a durable stores a confidential client + /// credential, not just the refresh token (which for a confidential client is not usable on its own). + /// Cache implementations that persist to durable storage must protect these values at rest (for + /// example with OS-level encryption or a dedicated secret store); otherwise a cache compromise would + /// expose a complete, usable credential set. + /// + /// + public string? ClientSecret { get; set; } + + /// + /// Gets or sets the token endpoint authentication method associated with . + /// + /// + /// This is persisted alongside so a refresh performed on a cold start uses the + /// same authentication method that was negotiated when the client was registered (for example + /// none for a public client rather than the default client_secret_post). + /// + public string? TokenEndpointAuthMethod { get; set; } + + /// + /// Gets or sets the authorization server issuer that issued the client credentials and tokens. + /// + /// + /// OAuth client credentials are bound to an authorization server and must not be reused with a + /// different issuer. Durable cache implementations should persist this value alongside the token + /// and client registration so restored credentials can be validated before use. + /// + public string? AuthorizationServer { get; set; } + internal bool IsExpired => ExpiresIn is not null && DateTimeOffset.UtcNow >= ObtainedAt.AddSeconds(ExpiresIn.Value); } diff --git a/src/ModelContextProtocol.Core/Client/AutoDetectingClientSessionTransport.cs b/src/ModelContextProtocol.Core/Client/AutoDetectingClientSessionTransport.cs index 209d644d2..c9e821adf 100644 --- a/src/ModelContextProtocol.Core/Client/AutoDetectingClientSessionTransport.cs +++ b/src/ModelContextProtocol.Core/Client/AutoDetectingClientSessionTransport.cs @@ -2,6 +2,7 @@ using Microsoft.Extensions.Logging.Abstractions; using ModelContextProtocol.Protocol; using System.Net; +using System.Net.Http; using System.Threading.Channels; namespace ModelContextProtocol.Client; @@ -73,25 +74,52 @@ private async Task InitializeAsync(JsonRpcMessage message, CancellationToken can LogUsingStreamableHttp(_name); ActiveTransport = streamableHttpTransport; } + else if (await StreamableHttpClientSessionTransport.TryReadJsonRpcErrorAsync(response, cancellationToken).ConfigureAwait(false) is { } parsedError) + { + // A JSON-RPC error envelope in the body means the peer IS a Streamable HTTP server. + // It just rejected our specific request (e.g., -32022 UnsupportedProtocolVersion, + // -32021 MissingRequiredClientCapability, -32020 HeaderMismatch, or any other + // application-level error). Don't fall back to SSE — that would mask the real signal + // and surface a misleading "session id required" error from the SSE GET path. + // Adopt the Streamable HTTP transport and throw the structured exception so the + // connect-time fallback logic can react per spec PR #2844. Setting ActiveTransport + // first makes the catch filter below leave the now-owned transport alone. + LogUsingStreamableHttp(_name); + ActiveTransport = streamableHttpTransport; + throw McpSessionHandler.CreateRemoteProtocolExceptionFromError(parsedError); + } else { - // If the status code is not success, fall back to SSE + // Non-JSON-RPC error response: either the server doesn't speak MCP at all, or this + // is an older deployment that expects the SSE transport (which establishes its + // protocol via GET /sse rather than POST). Fall back to SSE per the original + // behavior. Capture the underlying error (status + body) before falling back so that, + // if SSE also fails, we can surface the real Streamable HTTP diagnostic to the caller + // instead of dropping it on the floor (see https://github.com/modelcontextprotocol/csharp-sdk/issues/1526). LogStreamableHttpFailed(_name, response.StatusCode); + // This reads the response body a second time for the application/json case, where + // TryReadJsonRpcErrorAsync above already read it. HttpContent buffers after the first + // read, so this returns the same buffered content and is safe (not a second stream + // consumption). For the common non-JSON error responses (415, 405, plain text) + // TryReadJsonRpcErrorAsync returns early on the content type, so there is no double read. + var streamableHttpError = await HttpResponseMessageExtensions.CreateHttpRequestExceptionWithBodyAsync(response, cancellationToken).ConfigureAwait(false); + await streamableHttpTransport.DisposeAsync().ConfigureAwait(false); - await InitializeSseTransportAsync(message, cancellationToken).ConfigureAwait(false); + await InitializeSseTransportAsync(message, streamableHttpError, cancellationToken).ConfigureAwait(false); } } - catch + catch when (ActiveTransport is null) { - // If nothing threw inside the try block, we've either set streamableHttpTransport as the - // ActiveTransport, or else we will have disposed it in the !IsSuccessStatusCode else block. + // Only dispose the Streamable HTTP transport when we didn't adopt it. If we set + // ActiveTransport above (success path OR structured-error path), the transport's + // lifetime is owned by the outer transport from this point on. await streamableHttpTransport.DisposeAsync().ConfigureAwait(false); throw; } } - private async Task InitializeSseTransportAsync(JsonRpcMessage message, CancellationToken cancellationToken) + private async Task InitializeSseTransportAsync(JsonRpcMessage message, HttpRequestException? streamableHttpError, CancellationToken cancellationToken) { if (_options.KnownSessionId is not null) { @@ -109,6 +137,20 @@ private async Task InitializeSseTransportAsync(JsonRpcMessage message, Cancellat LogUsingSSE(_name); ActiveTransport = sseTransport; } + catch (Exception sseError) when (streamableHttpError is not null && sseError is not OperationCanceledException) + { + // SSE fallback also failed. Surface the original Streamable HTTP error as the primary failure so the + // user sees the real server diagnostic (e.g. 415 Unsupported Media Type) instead of the unrelated + // SSE-fallback error (e.g. a 405 from a Streamable-HTTP-only server that doesn't accept GET). Preserve + // the original status code and attach the SSE failure as the inner exception so neither is lost, and + // keep HttpRequestException as the surfaced type so existing callers can still catch it and read StatusCode. + await sseTransport.DisposeAsync().ConfigureAwait(false); + LogSseFallbackFailedAfterStreamableHttp(_name, sseError); + throw HttpRequestExceptionExtensions.Create( + streamableHttpError.Message, + sseError, + streamableHttpError.GetStatusCode()); + } catch { await sseTransport.DisposeAsync().ConfigureAwait(false); @@ -147,4 +189,7 @@ public async ValueTask DisposeAsync() [LoggerMessage(Level = LogLevel.Information, Message = "{EndpointName} using SSE transport.")] private partial void LogUsingSSE(string endpointName); -} \ No newline at end of file + + [LoggerMessage(Level = LogLevel.Warning, Message = "{EndpointName} SSE fallback failed after Streamable HTTP also failed; surfacing both errors.")] + private partial void LogSseFallbackFailedAfterStreamableHttp(string endpointName, Exception sseError); +} diff --git a/src/ModelContextProtocol.Core/Client/HttpClientTransportOptions.cs b/src/ModelContextProtocol.Core/Client/HttpClientTransportOptions.cs index f97c346ea..ce95f65f3 100644 --- a/src/ModelContextProtocol.Core/Client/HttpClientTransportOptions.cs +++ b/src/ModelContextProtocol.Core/Client/HttpClientTransportOptions.cs @@ -94,6 +94,24 @@ public required Uri Endpoint /// public string? KnownSessionId { get; set; } + /// + /// Gets or sets a value indicating whether the Streamable HTTP transport opens the standalone GET SSE stream + /// used to receive unsolicited server-to-client messages. + /// + /// + /// + /// This defaults to , matching the Streamable HTTP behavior of opening a standalone GET + /// SSE stream after initialization so the server can push unsolicited server-to-client messages. + /// + /// + /// Set this to for servers where the client does not need unsolicited server-to-client + /// messages, or when a long-lived standalone GET would block other requests under a constrained + /// connection pool. Direct responses and streaming responses to client POST requests + /// still work; only the standalone GET stream is skipped. + /// + /// + public bool EnableStandaloneGetStream { get; set; } = true; + /// /// Gets or sets a value indicating whether this transport endpoint is responsible for ending the session on dispose. /// diff --git a/src/ModelContextProtocol.Core/Client/McpClient.Methods.cs b/src/ModelContextProtocol.Core/Client/McpClient.Methods.cs index 673f66420..bccdd7a2e 100644 --- a/src/ModelContextProtocol.Core/Client/McpClient.Methods.cs +++ b/src/ModelContextProtocol.Core/Client/McpClient.Methods.cs @@ -1,4 +1,4 @@ -using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Logging; using ModelContextProtocol.Protocol; using ModelContextProtocol.Server; using System.Diagnostics; @@ -172,10 +172,26 @@ public ValueTask PingAsync( /// The to monitor for cancellation requests. The default is . /// A list of all available tools as instances. /// The request failed or the server returned an error response. + /// + /// + /// This overload aggregates every page into a single list and does not surface the per-result caching hints + /// ( and ). To read those hints, + /// use the overload, which returns the + /// raw for each page. + /// + /// + /// The SDK does not perform any internal caching of listing results; every call re-fetches all pages from the server. + /// If you want to cache listing results, do so in your own code using the lower-level + /// overload, which exposes the per-page + /// caching hints and lets you manage pagination so each page can be cached and expired independently. + /// + /// public async ValueTask> ListToolsAsync( RequestOptions? options = null, CancellationToken cancellationToken = default) { + ToolCacheClearing?.Invoke(); + List? tools = null; ListToolsRequestParams requestParams = new() { Meta = options?.GetMetaForRequest() }; do @@ -184,6 +200,17 @@ public async ValueTask> ListToolsAsync( tools ??= new(toolResults.Tools.Count); foreach (var tool in toolResults.Tools) { + // Validate x-mcp-header annotations per SEP-2243. The spec requires Streamable HTTP + // clients to exclude tools with invalid annotations and permits other transports + // (e.g., stdio) to ignore the annotations entirely. This client validates on all + // transports so a malformed definition is rejected consistently regardless of transport. + if (!McpHeaderExtractor.ValidateToolSchema(tool, out var rejectionReason)) + { + ToolRejected?.Invoke(tool, rejectionReason!); + continue; + } + + ToolDiscovered?.Invoke(tool); tools.Add(new(this, tool, options?.JsonSerializerOptions)); } @@ -194,6 +221,21 @@ public async ValueTask> ListToolsAsync( return tools; } + /// + /// Invoked when a tool definition is discovered from a tools/list response. + /// + internal Action? ToolDiscovered; + + /// + /// Invoked when a tool definition is rejected due to invalid x-mcp-header annotations. + /// + internal Action? ToolRejected; + + /// + /// Invoked before enumerating tools to clear any previously cached tool definitions. + /// + internal Action? ToolCacheClearing; + /// /// Retrieves a list of available tools from the server. /// @@ -213,12 +255,25 @@ public ValueTask ListToolsAsync( { Throw.IfNull(requestParams); - return SendRequestAsync( + return ValidateCacheableResultAsync(RequestMethods.ToolsList, SendRequestAsync( RequestMethods.ToolsList, requestParams, McpJsonUtilities.JsonContext.Default.ListToolsRequestParams, McpJsonUtilities.JsonContext.Default.ListToolsResult, - cancellationToken: cancellationToken); + cancellationToken: cancellationToken)); + } + + /// + /// Awaits a cacheable result and gives derived clients a chance to emit diagnostics (for example, a + /// SEP-2549 conformance warning) before returning it. Preserves the synchronous argument validation + /// performed by the callers before the request is issued. + /// + private async ValueTask ValidateCacheableResultAsync(string method, ValueTask resultTask) + where TResult : ICacheableResult + { + var result = await resultTask.ConfigureAwait(false); + ValidateCacheableResult(method, result); + return result; } /// @@ -228,6 +283,20 @@ public ValueTask ListToolsAsync( /// The to monitor for cancellation requests. The default is . /// A list of all available prompts as instances. /// The request failed or the server returned an error response. + /// + /// + /// This overload aggregates every page into a single list and does not surface the per-result caching hints + /// ( and ). To read those hints, + /// use the overload, which returns the + /// raw for each page. + /// + /// + /// The SDK does not perform any internal caching of listing results; every call re-fetches all pages from the server. + /// If you want to cache listing results, do so in your own code using the lower-level + /// overload, which exposes the per-page + /// caching hints and lets you manage pagination so each page can be cached and expired independently. + /// + /// public async ValueTask> ListPromptsAsync( RequestOptions? options = null, CancellationToken cancellationToken = default) @@ -269,12 +338,12 @@ public ValueTask ListPromptsAsync( { Throw.IfNull(requestParams); - return SendRequestAsync( + return ValidateCacheableResultAsync(RequestMethods.PromptsList, SendRequestAsync( RequestMethods.PromptsList, requestParams, McpJsonUtilities.JsonContext.Default.ListPromptsRequestParams, McpJsonUtilities.JsonContext.Default.ListPromptsResult, - cancellationToken: cancellationToken); + cancellationToken: cancellationToken)); } /// @@ -338,6 +407,20 @@ public ValueTask GetPromptAsync( /// The to monitor for cancellation requests. The default is . /// A list of all available resource templates as instances. /// The request failed or the server returned an error response. + /// + /// + /// This overload aggregates every page into a single list and does not surface the per-result caching hints + /// ( and ). To read those hints, + /// use the overload, which returns the + /// raw for each page. + /// + /// + /// The SDK does not perform any internal caching of listing results; every call re-fetches all pages from the server. + /// If you want to cache listing results, do so in your own code using the lower-level + /// overload, which exposes the per-page + /// caching hints and lets you manage pagination so each page can be cached and expired independently. + /// + /// public async ValueTask> ListResourceTemplatesAsync( RequestOptions? options = null, CancellationToken cancellationToken = default) @@ -379,12 +462,12 @@ public ValueTask ListResourceTemplatesAsync( { Throw.IfNull(requestParams); - return SendRequestAsync( + return ValidateCacheableResultAsync(RequestMethods.ResourcesTemplatesList, SendRequestAsync( RequestMethods.ResourcesTemplatesList, requestParams, McpJsonUtilities.JsonContext.Default.ListResourceTemplatesRequestParams, McpJsonUtilities.JsonContext.Default.ListResourceTemplatesResult, - cancellationToken: cancellationToken); + cancellationToken: cancellationToken)); } /// @@ -394,6 +477,20 @@ public ValueTask ListResourceTemplatesAsync( /// The to monitor for cancellation requests. The default is . /// A list of all available resources as instances. /// The request failed or the server returned an error response. + /// + /// + /// This overload aggregates every page into a single list and does not surface the per-result caching hints + /// ( and ). To read those hints, + /// use the overload, which returns the + /// raw for each page. + /// + /// + /// The SDK does not perform any internal caching of listing results; every call re-fetches all pages from the server. + /// If you want to cache listing results, do so in your own code using the lower-level + /// overload, which exposes the per-page + /// caching hints and lets you manage pagination so each page can be cached and expired independently. + /// + /// public async ValueTask> ListResourcesAsync( RequestOptions? options = null, CancellationToken cancellationToken = default) @@ -435,12 +532,12 @@ public ValueTask ListResourcesAsync( { Throw.IfNull(requestParams); - return SendRequestAsync( + return ValidateCacheableResultAsync(RequestMethods.ResourcesList, SendRequestAsync( RequestMethods.ResourcesList, requestParams, McpJsonUtilities.JsonContext.Default.ListResourcesRequestParams, McpJsonUtilities.JsonContext.Default.ListResourcesResult, - cancellationToken: cancellationToken); + cancellationToken: cancellationToken)); } /// @@ -519,12 +616,12 @@ public ValueTask ReadResourceAsync( { Throw.IfNull(requestParams); - return SendRequestAsync( + return ValidateCacheableResultAsync(RequestMethods.ResourcesRead, SendRequestAsync( RequestMethods.ResourcesRead, requestParams, McpJsonUtilities.JsonContext.Default.ReadResourceRequestParams, McpJsonUtilities.JsonContext.Default.ReadResourceResult, - cancellationToken: cancellationToken); + cancellationToken: cancellationToken)); } /// @@ -636,6 +733,12 @@ public Task SubscribeToResourceAsync(string uri, RequestOptions? options = null, /// For a simpler API that handles both subscription and notification registration in a single call, /// use . /// + /// + /// The 2026-07-28 protocol revision (SEP-2575) removed resources/subscribe in favor of + /// with resourceSubscriptions. On a session that + /// negotiated that revision or later, this method throws an with + /// . + /// /// public Task SubscribeToResourceAsync( SubscribeRequestParams requestParams, @@ -834,6 +937,12 @@ public Task UnsubscribeFromResourceAsync(string uri, RequestOptions? options = n /// The result of the request. /// is . /// The request failed or the server returned an error response. + /// + /// The 2026-07-28 protocol revision (SEP-2575) removed resources/unsubscribe in favor of + /// with resourceSubscriptions. On a session that + /// negotiated that revision or later, this method throws an with + /// . + /// public Task UnsubscribeFromResourceAsync( UnsubscribeRequestParams requestParams, CancellationToken cancellationToken = default) @@ -847,16 +956,15 @@ public Task UnsubscribeFromResourceAsync( McpJsonUtilities.JsonContext.Default.EmptyResult, cancellationToken: cancellationToken).AsTask(); } - /// /// Invokes a tool on the server. /// - /// The name of the tool to call on the server. + /// The name of the tool to invoke. /// An optional dictionary of arguments to pass to the tool. - /// An optional progress reporter for server notifications. + /// An optional progress handler for tracking operation progress. /// Optional request options including metadata, serialization settings, and progress tracking. /// The to monitor for cancellation requests. The default is . - /// The from the tool execution. + /// The result of the tool invocation. /// is . /// The request failed or the server returned an error response. public ValueTask CallToolAsync( @@ -942,331 +1050,6 @@ public ValueTask CallToolAsync( McpJsonUtilities.JsonContext.Default.CallToolResult, cancellationToken: cancellationToken); } - - /// - /// Invokes a tool on the server as a task for long-running operations. - /// - /// The name of the tool to call on the server. - /// An optional dictionary of arguments to pass to the tool. - /// Metadata for task augmentation, including optional TTL. If , an empty metadata is used. - /// An optional progress reporter for server notifications. - /// Optional request options including metadata, serialization settings, and progress tracking. - /// The to monitor for cancellation requests. The default is . - /// - /// An representing the created task. Use to poll for status updates - /// and to retrieve the final result. - /// - /// is . - /// The request failed or the server returned an error response. - /// - /// - /// Task-augmented tool calls allow long-running operations to be executed asynchronously. Instead of blocking - /// until the tool completes, the server immediately returns a task identifier that can be used to poll for - /// status updates and retrieve the final result. - /// - /// - /// The server must advertise task support via capabilities.tasks.requests.tools.call and the tool - /// must have execution.taskSupport set to "optional" or "required". - /// - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - public ValueTask CallToolAsTaskAsync( - string toolName, - IReadOnlyDictionary? arguments = null, - McpTaskMetadata? taskMetadata = null, - IProgress? progress = null, - RequestOptions? options = null, - CancellationToken cancellationToken = default) - { - Throw.IfNull(toolName); - - var serializerOptions = options?.JsonSerializerOptions ?? McpJsonUtilities.DefaultOptions; - serializerOptions.MakeReadOnly(); - - if (progress is null) - { - return SendTaskAugmentedCallToolRequestAsync(toolName, arguments, taskMetadata, options?.GetMetaForRequest(), serializerOptions, cancellationToken); - } - - return SendTaskAugmentedCallToolRequestWithProgressAsync(toolName, arguments, taskMetadata, progress, options?.GetMetaForRequest(), serializerOptions, cancellationToken); - - async ValueTask SendTaskAugmentedCallToolRequestAsync( - string toolName, - IReadOnlyDictionary? arguments, - McpTaskMetadata? taskMetadata, - JsonObject? meta, - JsonSerializerOptions serializerOptions, - CancellationToken cancellationToken) - { - var result = await SendRequestAsync( - RequestMethods.ToolsCall, - new CallToolRequestParams - { - Name = toolName, - Arguments = ToArgumentsDictionary(arguments, serializerOptions), - Meta = meta, - Task = taskMetadata ?? new McpTaskMetadata(), - }, - McpJsonUtilities.JsonContext.Default.CallToolRequestParams, - McpJsonUtilities.JsonContext.Default.CreateTaskResult, - cancellationToken: cancellationToken).ConfigureAwait(false); - - return result.Task; - } - - async ValueTask SendTaskAugmentedCallToolRequestWithProgressAsync( - string toolName, - IReadOnlyDictionary? arguments, - McpTaskMetadata? taskMetadata, - IProgress progress, - JsonObject? meta, - JsonSerializerOptions serializerOptions, - CancellationToken cancellationToken) - { - ProgressToken progressToken = new(Guid.NewGuid().ToString("N")); - - await using var _ = RegisterNotificationHandler(NotificationMethods.ProgressNotification, - (notification, cancellationToken) => - { - if (JsonSerializer.Deserialize(notification.Params, McpJsonUtilities.JsonContext.Default.ProgressNotificationParams) is { } pn && - pn.ProgressToken == progressToken) - { - progress.Report(pn.Progress); - } - - return default; - }).ConfigureAwait(false); - - JsonObject metaWithProgress = meta is not null ? (JsonObject)meta.DeepClone() : []; - metaWithProgress["progressToken"] = progressToken.ToString(); - - var result = await SendRequestAsync( - RequestMethods.ToolsCall, - new CallToolRequestParams - { - Name = toolName, - Arguments = ToArgumentsDictionary(arguments, serializerOptions), - Meta = metaWithProgress, - Task = taskMetadata ?? new McpTaskMetadata(), - }, - McpJsonUtilities.JsonContext.Default.CallToolRequestParams, - McpJsonUtilities.JsonContext.Default.CreateTaskResult, - cancellationToken: cancellationToken).ConfigureAwait(false); - - return result.Task; - } - } - - /// - /// Retrieves the current state of a specific task from the server. - /// - /// The unique identifier of the task to retrieve. - /// Optional request options including metadata, serialization settings, and progress tracking. - /// The to monitor for cancellation requests. The default is . - /// The current state of the task. - /// is . - /// is empty or composed entirely of whitespace. - /// The request failed or the server returned an error response. - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - public async ValueTask GetTaskAsync( - string taskId, - RequestOptions? options = null, - CancellationToken cancellationToken = default) - { - Throw.IfNullOrWhiteSpace(taskId); - - var result = await SendRequestAsync( - RequestMethods.TasksGet, - new GetTaskRequestParams { TaskId = taskId, Meta = options?.GetMetaForRequest() }, - McpJsonUtilities.JsonContext.Default.GetTaskRequestParams, - McpJsonUtilities.JsonContext.Default.GetTaskResult, - cancellationToken: cancellationToken).ConfigureAwait(false); - - // Convert GetTaskResult to McpTask - return new McpTask - { - TaskId = result.TaskId, - Status = result.Status, - StatusMessage = result.StatusMessage, - CreatedAt = result.CreatedAt, - LastUpdatedAt = result.LastUpdatedAt, - TimeToLive = result.TimeToLive, - PollInterval = result.PollInterval - }; - } - - /// - /// Retrieves the result of a completed task, blocking until the task reaches a terminal state. - /// - /// The unique identifier of the task whose result to retrieve. - /// Optional request options including metadata, serialization settings, and progress tracking. - /// The to monitor for cancellation requests. The default is . - /// The raw JSON result of the task. - /// is . - /// is empty or composed entirely of whitespace. - /// The request failed or the server returned an error response. - /// - /// This method sends a tasks/result request to the server, which will block until the task completes if it hasn't already. - /// The server handles all polling logic internally. - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - public ValueTask GetTaskResultAsync( - string taskId, - RequestOptions? options = null, - CancellationToken cancellationToken = default) - { - Throw.IfNullOrWhiteSpace(taskId); - - return SendRequestAsync( - RequestMethods.TasksResult, - new GetTaskPayloadRequestParams { TaskId = taskId, Meta = options?.GetMetaForRequest() }, - McpJsonUtilities.JsonContext.Default.GetTaskPayloadRequestParams, - McpJsonUtilities.JsonContext.Default.JsonElement, - cancellationToken: cancellationToken); - } - - /// - /// Retrieves a list of all tasks from the server. - /// - /// Optional request options including metadata, serialization settings, and progress tracking. - /// The to monitor for cancellation requests. The default is . - /// A list of all tasks. - /// The request failed or the server returned an error response. - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - public async ValueTask> ListTasksAsync( - RequestOptions? options = null, - CancellationToken cancellationToken = default) - { - ListTasksRequestParams requestParams = new() { Meta = options?.GetMetaForRequest() }; - List tasks = new(); - do - { - var taskResults = await ListTasksAsync(requestParams, cancellationToken).ConfigureAwait(false); - tasks.AddRange(taskResults.Tasks); - requestParams.Cursor = taskResults.NextCursor; - } - while (requestParams.Cursor is not null); - - return tasks; - } - - /// - /// Retrieves a list of tasks from the server. - /// - /// The request parameters to send in the request. - /// The to monitor for cancellation requests. The default is . - /// The result of the request as provided by the server. - /// is . - /// The request failed or the server returned an error response. - /// - /// The overload retrieves all tasks by automatically handling pagination. - /// This overload works with the lower-level and , returning the raw result from the server. - /// Any pagination needs to be managed by the caller. - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - public ValueTask ListTasksAsync( - ListTasksRequestParams requestParams, - CancellationToken cancellationToken = default) - { - Throw.IfNull(requestParams); - - return SendRequestAsync( - RequestMethods.TasksList, - requestParams, - McpJsonUtilities.JsonContext.Default.ListTasksRequestParams, - McpJsonUtilities.JsonContext.Default.ListTasksResult, - cancellationToken: cancellationToken); - } - - /// - /// Cancels a running task on the server. - /// - /// The unique identifier of the task to cancel. - /// Optional request options including metadata, serialization settings, and progress tracking. - /// The to monitor for cancellation requests. The default is . - /// The updated state of the task after cancellation. - /// is . - /// is empty or composed entirely of whitespace. - /// The request failed or the server returned an error response. - /// - /// Cancelling a task requests that the server stop execution. The server may not immediately cancel the task, - /// and may choose to allow the task to complete if it's close to finishing. - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - public async ValueTask CancelTaskAsync( - string taskId, - RequestOptions? options = null, - CancellationToken cancellationToken = default) - { - Throw.IfNullOrWhiteSpace(taskId); - - var result = await SendRequestAsync( - RequestMethods.TasksCancel, - new CancelMcpTaskRequestParams { TaskId = taskId, Meta = options?.GetMetaForRequest() }, - McpJsonUtilities.JsonContext.Default.CancelMcpTaskRequestParams, - McpJsonUtilities.JsonContext.Default.CancelMcpTaskResult, - cancellationToken: cancellationToken).ConfigureAwait(false); - - // Convert CancelMcpTaskResult to McpTask - return new McpTask - { - TaskId = result.TaskId, - Status = result.Status, - StatusMessage = result.StatusMessage, - CreatedAt = result.CreatedAt, - LastUpdatedAt = result.LastUpdatedAt, - TimeToLive = result.TimeToLive, - PollInterval = result.PollInterval - }; - } - - /// - /// Polls a task until it reaches a terminal status (completed, failed, or cancelled). - /// - /// The unique identifier of the task to poll. - /// Optional request options including metadata, serialization settings, and progress tracking. - /// The to monitor for cancellation requests. The default is . - /// The task in its terminal state. - /// is . - /// is empty or composed entirely of whitespace. - /// - /// - /// This method repeatedly calls until the task reaches a terminal status. - /// It respects the returned by the server to determine how long - /// to wait between polling attempts. - /// - /// - /// For retrieving the actual result of a completed task, use . - /// - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - public async ValueTask PollTaskUntilCompleteAsync( - string taskId, - RequestOptions? options = null, - CancellationToken cancellationToken = default) - { - Throw.IfNullOrWhiteSpace(taskId); - - McpTask task; - do - { - task = await GetTaskAsync(taskId, options, cancellationToken).ConfigureAwait(false); - - // If task is in a terminal state, we're done - if (task.Status is McpTaskStatus.Completed or McpTaskStatus.Failed or McpTaskStatus.Cancelled) - { - break; - } - - // Wait for the poll interval before checking again (default to 1 second) - var pollInterval = task.PollInterval ?? TimeSpan.FromSeconds(1); - await Task.Delay(pollInterval, cancellationToken).ConfigureAwait(false); - } - while (true); - - return task; - } - /// /// Sets the logging level for the server to control which log messages are sent to the client. /// @@ -1275,6 +1058,7 @@ public async ValueTask PollTaskUntilCompleteAsync( /// The to monitor for cancellation requests. The default is . /// A task representing the asynchronous operation. /// The request failed or the server returned an error response. + [Obsolete(Obsoletions.DeprecatedLogging_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public Task SetLoggingLevelAsync(LogLevel level, RequestOptions? options = null, CancellationToken cancellationToken = default) => SetLoggingLevelAsync(McpServerImpl.ToLoggingLevel(level), options, cancellationToken); @@ -1286,6 +1070,7 @@ public Task SetLoggingLevelAsync(LogLevel level, RequestOptions? options = null, /// The to monitor for cancellation requests. The default is . /// A task representing the asynchronous operation. /// The request failed or the server returned an error response. + [Obsolete(Obsoletions.DeprecatedLogging_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public Task SetLoggingLevelAsync(LoggingLevel level, RequestOptions? options = null, CancellationToken cancellationToken = default) { return SetLoggingLevelAsync( @@ -1305,6 +1090,7 @@ public Task SetLoggingLevelAsync(LoggingLevel level, RequestOptions? options = n /// The result of the request. /// is . /// The request failed or the server returned an error response. + [Obsolete(Obsoletions.DeprecatedLogging_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public Task SetLoggingLevelAsync( SetLevelRequestParams requestParams, CancellationToken cancellationToken = default) @@ -1318,8 +1104,6 @@ public Task SetLoggingLevelAsync( McpJsonUtilities.JsonContext.Default.EmptyResult, cancellationToken: cancellationToken).AsTask(); } - - /// Converts a dictionary with values to a dictionary with values. private static Dictionary? ToArgumentsDictionary( IReadOnlyDictionary? arguments, JsonSerializerOptions options) { @@ -1337,4 +1121,5 @@ public Task SetLoggingLevelAsync( return result; } + } diff --git a/src/ModelContextProtocol.Core/Client/McpClient.cs b/src/ModelContextProtocol.Core/Client/McpClient.cs index 406969121..67bb21a8d 100644 --- a/src/ModelContextProtocol.Core/Client/McpClient.cs +++ b/src/ModelContextProtocol.Core/Client/McpClient.cs @@ -1,4 +1,5 @@ using System.Diagnostics.CodeAnalysis; +using System.Text.Json; using ModelContextProtocol.Protocol; namespace ModelContextProtocol.Client; @@ -11,7 +12,7 @@ public abstract partial class McpClient : McpSession /// /// Initializes a new instance of the class. /// - [Experimental(Experimentals.Subclassing_DiagnosticId, UrlFormat = Experimentals.Subclassing_Url)] + [Experimental(Experimentals.Extensibility_DiagnosticId, UrlFormat = Experimentals.Extensibility_Url)] protected McpClient() { } @@ -28,14 +29,16 @@ protected McpClient() /// /// /// This property provides identification details about the connected server, including its name and version. - /// It is populated during the initialization handshake and is available after a successful connection. + /// It is populated during the initialization handshake or from server/discover result metadata. /// /// /// This information can be useful for logging, debugging, compatibility checks, and displaying server /// information to users. /// /// - /// The client is not connected. + /// + /// The client is not connected, or the server omitted the optional server identity metadata. + /// public abstract Implementation ServerInfo { get; } /// @@ -70,4 +73,111 @@ protected McpClient() /// /// public abstract Task Completion { get; } + + /// + /// Resolves input requests by dispatching + /// each request to the appropriate registered handler. + /// + /// + /// The input requests from the task, keyed by request identifier. Each value is an + /// wrapping the server-to-client request payload. + /// + /// The to monitor for cancellation requests. + /// A dictionary of responses keyed by the same identifiers as the input requests. + public abstract ValueTask> ResolveInputRequestsAsync( + IDictionary inputRequests, CancellationToken cancellationToken); + + /// + /// Inspects a received cacheable result (tools/list, prompts/list, resources/list, + /// resources/templates/list, or resources/read) so derived clients can emit diagnostics. + /// + /// The request method that produced the result. + /// The cacheable result returned by the server. + /// + /// This is used to warn (never throw) when a server that negotiated a protocol version requiring the + /// SEP-2549 ttlMs/cacheScope fields omits them. The default implementation does nothing. + /// + private protected virtual void ValidateCacheableResult(string method, ICacheableResult result) + { + } + + /// + /// Registers one or more tool definitions in the client's tool cache, enabling the transport + /// to send Mcp-Param-* headers for those tools without requiring a prior call. + /// + /// The tool definitions to register. + /// + /// + /// This method allows callers who already have tool schema information (e.g., from a previous session, + /// hardcoded configuration, or an out-of-band source) to provide it directly to the client. Once registered, + /// any + /// call for a registered tool will automatically include Mcp-Param-* HTTP headers based on + /// the tool's x-mcp-header schema annotations, exactly as if the tool had been discovered + /// via . + /// + /// + /// Cache interaction behavior: + /// + /// Registered tools are added to the same internal tool cache used by . + /// Calling after preserves + /// manually registered tools — only server-discovered tools are cleared and repopulated. + /// If the server returns a tool with the same name as a manually registered tool, the server's + /// definition overwrites the registered one in the cache, but the tool retains its known status + /// and will survive subsequent cache clears. This registration is sticky for the lifetime of the + /// ; use or to + /// explicitly drop known tools that are no longer needed. + /// Tools can be registered at any time — before or after , + /// and across multiple calls. + /// Re-registering a tool with the same name overwrites the previous definition in the cache (last write wins). + /// + /// + /// + /// Tools with invalid x-mcp-header annotations cause an to be thrown. + /// No tools are added to the cache if any tool in the batch fails validation (all-or-nothing). + /// + /// + /// is . + /// One or more tools have invalid x-mcp-header annotations. + public virtual void AddKnownTools(IEnumerable tools) + { + Throw.IfNull(tools); + throw new NotSupportedException($"{GetType().Name} does not support adding known tools."); + } + + /// + /// Removes one or more previously registered tool definitions from the client's tool cache by name. + /// + /// The names of the tools to remove. + /// + /// + /// This removes the specified tools from both the known-tools set and the internal tool cache. + /// After removal, those tools will no longer survive + /// cache clears, and Mcp-Param-* headers will no longer be sent for them unless the server + /// re-discovers them via . + /// + /// + /// Removing a tool name that was not previously added via is a no-op. + /// + /// + /// is . + public virtual void RemoveKnownTools(IEnumerable toolNames) + { + Throw.IfNull(toolNames); + throw new NotSupportedException($"{GetType().Name} does not support removing known tools."); + } + + /// + /// Removes all previously registered tool definitions from the client's tool cache. + /// + /// + /// + /// This clears all tools that were added via from both the known-tools + /// set and the internal tool cache. Server-discovered tools that are not also known tools are not affected + /// and will remain in the cache until the next call. + /// + /// + public virtual void ClearKnownTools() + { + throw new NotSupportedException($"{GetType().Name} does not support clearing known tools."); + } } diff --git a/src/ModelContextProtocol.Core/Client/McpClientHandlers.cs b/src/ModelContextProtocol.Core/Client/McpClientHandlers.cs index 2109555bc..396b5876b 100644 --- a/src/ModelContextProtocol.Core/Client/McpClientHandlers.cs +++ b/src/ModelContextProtocol.Core/Client/McpClientHandlers.cs @@ -1,4 +1,4 @@ -using Microsoft.Extensions.AI; +using Microsoft.Extensions.AI; using ModelContextProtocol.Protocol; using System.Diagnostics.CodeAnalysis; @@ -50,6 +50,7 @@ public sealed class McpClientHandlers /// This handler is invoked when the server sends a request to retrieve available roots. /// The handler receives request parameters and should return a containing the collection of available roots. /// + [Obsolete(Obsoletions.DeprecatedRoots_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public Func>? RootsHandler { get; set; } /// @@ -85,26 +86,6 @@ public sealed class McpClientHandlers /// method with any implementation of . /// /// + [Obsolete(Obsoletions.DeprecatedSampling_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public Func, CancellationToken, ValueTask>? SamplingHandler { get; set; } - - /// - /// Gets or sets the handler for processing notifications. - /// - /// - /// - /// This handler is called when the server sends a task status notification to inform the client - /// about changes to a task's state. These notifications are optional and clients MUST NOT rely - /// on receiving them. - /// - /// - /// The handler receives the updated object containing the current task state, - /// including its status, status message, and timestamps. - /// - /// - /// This handler is typically used to update UI or trigger actions based on task progress - /// without requiring explicit polling. - /// - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - public Func? TaskStatusHandler { get; set; } } diff --git a/src/ModelContextProtocol.Core/Client/McpClientImpl.cs b/src/ModelContextProtocol.Core/Client/McpClientImpl.cs index 4205c28e1..a62ad0eea 100644 --- a/src/ModelContextProtocol.Core/Client/McpClientImpl.cs +++ b/src/ModelContextProtocol.Core/Client/McpClientImpl.cs @@ -1,7 +1,10 @@ using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging.Abstractions; using ModelContextProtocol.Protocol; +using System.Collections.Concurrent; +using System.Net; using System.Text.Json; +using System.Text.Json.Nodes; namespace ModelContextProtocol.Client; @@ -21,7 +24,9 @@ internal sealed partial class McpClientImpl : McpClient private readonly McpClientOptions _options; private readonly McpSessionHandler _sessionHandler; private readonly SemaphoreSlim _disposeLock = new(1, 1); - private readonly McpTaskCancellationTokenProvider? _taskCancellationTokenProvider; + private readonly ConcurrentDictionary _toolCache = new(StringComparer.Ordinal); + private readonly ConcurrentDictionary _registeredToolNames = new(StringComparer.Ordinal); + private readonly ConcurrentDictionary _cacheableConformanceWarnedMethods = new(StringComparer.Ordinal); private ServerCapabilities? _serverCapabilities; private Implementation? _serverInfo; @@ -47,12 +52,6 @@ internal McpClientImpl(ITransport transport, string endpointName, McpClientOptio _options = options; _logger = loggerFactory?.CreateLogger() ?? NullLogger.Instance; - // Only allocate the cancellation token provider if a task store is configured - if (options.TaskStore is not null) - { - _taskCancellationTokenProvider = new(); - } - var notificationHandlers = new NotificationHandlers(); var requestHandlers = new RequestHandlers(); @@ -67,6 +66,26 @@ internal McpClientImpl(ITransport transport, string endpointName, McpClientOptio incomingMessageFilter: null, outgoingMessageFilter: null, _logger); + + ToolDiscovered = tool => _toolCache[tool.Name] = tool; + ToolRejected = (tool, reason) => LogToolRejected(tool.Name, reason); + ToolCacheClearing = () => + { + if (_registeredToolNames.IsEmpty) + { + _toolCache.Clear(); + return; + } + + // Only remove server-discovered tools; preserve manually registered tools. + foreach (var key in _toolCache.Keys) + { + if (!_registeredToolNames.ContainsKey(key)) + { + _toolCache.TryRemove(key, out _); + } + } + }; } private void RegisterHandlers(McpClientOptions options, NotificationHandlers notificationHandlers, RequestHandlers requestHandlers) @@ -77,89 +96,26 @@ private void RegisterHandlers(McpClientOptions options, NotificationHandlers not var samplingHandler = handlers.SamplingHandler; var rootsHandler = handlers.RootsHandler; var elicitationHandler = handlers.ElicitationHandler; - var taskStatusHandler = handlers.TaskStatusHandler; - var taskStore = options.TaskStore; if (notificationHandlersFromOptions is not null) { notificationHandlers.RegisterRange(notificationHandlersFromOptions); } - if (taskStatusHandler is not null) - { - notificationHandlers.Register( - NotificationMethods.TaskStatusNotification, - (notification, cancellationToken) => - { - if (JsonSerializer.Deserialize(notification.Params, McpJsonUtilities.JsonContext.Default.McpTaskStatusNotificationParams) is { } notificationParams) - { - var task = new McpTask - { - TaskId = notificationParams.TaskId, - Status = notificationParams.Status, - StatusMessage = notificationParams.StatusMessage, - CreatedAt = notificationParams.CreatedAt, - LastUpdatedAt = notificationParams.LastUpdatedAt, - TimeToLive = notificationParams.TimeToLive, - PollInterval = notificationParams.PollInterval - }; - return taskStatusHandler(task, cancellationToken); - } - - return default; - }); - } - if (samplingHandler is not null) { - // If task store is configured, wrap the handler to support task-augmented requests - if (taskStore is not null) - { - requestHandlers.Set( - RequestMethods.SamplingCreateMessage, - async (request, jsonRpcRequest, cancellationToken) => - { - // Check if this is a task-augmented request - if (request?.Task is { } taskMetadata) - { - // Create task in store and return immediately - return await ExecuteAsTaskAsync( - taskStore, - taskMetadata, - jsonRpcRequest, - async ct => - { - var result = await samplingHandler( - request, - request.ProgressToken is { } token ? new TokenProgress(this, token) : NullProgress.Instance, - ct).ConfigureAwait(false); - return JsonSerializer.SerializeToElement(result, McpJsonUtilities.JsonContext.Default.CreateMessageResult); - }, - options.SendTaskStatusNotifications, - cancellationToken).ConfigureAwait(false); - } - - // Normal synchronous execution - serialize result to JsonElement - var samplingResult = await samplingHandler( - request, - request?.ProgressToken is { } token ? new TokenProgress(this, token) : NullProgress.Instance, - cancellationToken).ConfigureAwait(false); - return JsonSerializer.SerializeToElement(samplingResult, McpJsonUtilities.JsonContext.Default.CreateMessageResult); - }, - McpJsonUtilities.JsonContext.Default.CreateMessageRequestParams, - McpJsonUtilities.JsonContext.Default.JsonElement); // Return JsonElement to support both CreateMessageResult and CreateTaskResult - } - else - { - requestHandlers.Set( - RequestMethods.SamplingCreateMessage, - (request, _, cancellationToken) => samplingHandler( + requestHandlers.Set( + RequestMethods.SamplingCreateMessage, + (request, _, cancellationToken) => + { + WarnIfLegacyRequestOnMrtrSession(RequestMethods.SamplingCreateMessage); + return samplingHandler( request, request?.ProgressToken is { } token ? new TokenProgress(this, token) : NullProgress.Instance, - cancellationToken), - McpJsonUtilities.JsonContext.Default.CreateMessageRequestParams, - McpJsonUtilities.JsonContext.Default.CreateMessageResult); - } + cancellationToken); + }, + McpJsonUtilities.JsonContext.Default.CreateMessageRequestParams, + McpJsonUtilities.JsonContext.Default.CreateMessageResult); _options.Capabilities ??= new(); _options.Capabilities.Sampling ??= new(); @@ -169,7 +125,11 @@ private void RegisterHandlers(McpClientOptions options, NotificationHandlers not { requestHandlers.Set( RequestMethods.RootsList, - (request, _, cancellationToken) => rootsHandler(request, cancellationToken), + (request, _, cancellationToken) => + { + WarnIfLegacyRequestOnMrtrSession(RequestMethods.RootsList); + return rootsHandler(request, cancellationToken); + }, McpJsonUtilities.JsonContext.Default.ListRootsRequestParams, McpJsonUtilities.JsonContext.Default.ListRootsResult); @@ -179,51 +139,16 @@ private void RegisterHandlers(McpClientOptions options, NotificationHandlers not if (elicitationHandler is not null) { - // If task store is configured, wrap the handler to support task-augmented requests - if (taskStore is not null) - { - requestHandlers.Set( - RequestMethods.ElicitationCreate, - async (request, jsonRpcRequest, cancellationToken) => - { - // Check if this is a task-augmented request - if (request?.Task is { } taskMetadata) - { - // Create task in store and return immediately - return await ExecuteAsTaskAsync( - taskStore, - taskMetadata, - jsonRpcRequest, - async ct => - { - var result = await elicitationHandler(request, ct).ConfigureAwait(false); - result = ElicitResult.WithDefaults(request, result); - return JsonSerializer.SerializeToElement(result, McpJsonUtilities.JsonContext.Default.ElicitResult); - }, - options.SendTaskStatusNotifications, - cancellationToken).ConfigureAwait(false); - } - - // Normal synchronous execution - serialize result to JsonElement - var elicitResult = await elicitationHandler(request, cancellationToken).ConfigureAwait(false); - elicitResult = ElicitResult.WithDefaults(request, elicitResult); - return JsonSerializer.SerializeToElement(elicitResult, McpJsonUtilities.JsonContext.Default.ElicitResult); - }, - McpJsonUtilities.JsonContext.Default.ElicitRequestParams, - McpJsonUtilities.JsonContext.Default.JsonElement); // Return JsonElement to support both ElicitResult and CreateTaskResult - } - else - { - requestHandlers.Set( - RequestMethods.ElicitationCreate, - async (request, _, cancellationToken) => - { - var result = await elicitationHandler(request, cancellationToken).ConfigureAwait(false); - return ElicitResult.WithDefaults(request, result); - }, - McpJsonUtilities.JsonContext.Default.ElicitRequestParams, - McpJsonUtilities.JsonContext.Default.ElicitResult); - } + requestHandlers.Set( + RequestMethods.ElicitationCreate, + async (request, _, cancellationToken) => + { + WarnIfLegacyRequestOnMrtrSession(RequestMethods.ElicitationCreate); + var result = await elicitationHandler(request, cancellationToken).ConfigureAwait(false); + return ElicitResult.WithDefaults(request, result); + }, + McpJsonUtilities.JsonContext.Default.ElicitRequestParams, + McpJsonUtilities.JsonContext.Default.ElicitResult); _options.Capabilities ??= new(); _options.Capabilities.Elicitation ??= new(); @@ -234,296 +159,121 @@ private void RegisterHandlers(McpClientOptions options, NotificationHandlers not _options.Capabilities.Elicitation.Form = new(); } } - - // Register task handlers if a task store is configured - if (taskStore is not null) - { - RegisterTaskHandlers(requestHandlers, taskStore); - } } - /// - /// Executes an operation as a task, creating the task immediately and running the operation asynchronously. - /// - private async ValueTask ExecuteAsTaskAsync( - IMcpTaskStore taskStore, - McpTaskMetadata taskMetadata, - JsonRpcRequest jsonRpcRequest, - Func> operation, - bool sendNotifications, - CancellationToken cancellationToken) - { - // Create the task in the store - var mcpTask = await taskStore.CreateTaskAsync( - taskMetadata, - jsonRpcRequest.Id, - jsonRpcRequest, - SessionId, - cancellationToken).ConfigureAwait(false); + /// + public override string? SessionId => _transport.SessionId; - // Register the task for TTL-based cancellation - var taskCancellationToken = _taskCancellationTokenProvider!.RequestToken(mcpTask.TaskId, mcpTask.TimeToLive); + /// + public override string? NegotiatedProtocolVersion => _negotiatedProtocolVersion; - // Execute the operation asynchronously in the background - _ = Task.Run(async () => - { - try - { - // Send notification if enabled - if (sendNotifications) - { - var workingTask = await taskStore.GetTaskAsync(mcpTask.TaskId, SessionId, CancellationToken.None).ConfigureAwait(false); - if (workingTask is not null) - { - _ = NotifyTaskStatusAsync(workingTask, CancellationToken.None); - } - } + /// + public override ServerCapabilities ServerCapabilities => _serverCapabilities ?? throw new InvalidOperationException("The client is not connected."); + + /// + public override Implementation ServerInfo => _serverInfo ?? throw new InvalidOperationException( + "The client is not connected, or the connected server did not provide optional server identity metadata."); - // Execute the operation with task-specific cancellation token - var result = await operation(taskCancellationToken).ConfigureAwait(false); + /// + public override string? ServerInstructions => _serverInstructions; - // Store the result - var completedTask = await taskStore.StoreTaskResultAsync( - mcpTask.TaskId, - McpTaskStatus.Completed, - result, - SessionId, - CancellationToken.None).ConfigureAwait(false); + /// + public override Task Completion => _sessionHandler.CompletionTask; - // Send final notification if enabled - if (sendNotifications) - { - _ = NotifyTaskStatusAsync(completedTask, CancellationToken.None); - } - } - catch (OperationCanceledException) when (taskCancellationToken.IsCancellationRequested) - { - // Task was cancelled via TTL expiration or explicit cancellation. - // For TTL expiration, the task is deleted so no status update needed. - // For explicit cancellation, the cancel handler already updates the status. - } - catch (Exception ex) + /// + + /// + public override async ValueTask> ResolveInputRequestsAsync( + IDictionary inputRequests, + CancellationToken cancellationToken) + { + // Resolve all input requests concurrently. If any fails, cancel the rest so user-facing + // handlers (sampling/elicitation prompts) don't keep running for a request whose caller + // has already given up, and ensure exceptions from late-completing tasks are observed. + using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken); + + var keyed = new (string Key, Task Task)[inputRequests.Count]; + int i = 0; + foreach (var kvp in inputRequests) + { + keyed[i++] = (kvp.Key, ResolveInputRequestAsync(kvp.Value, linkedCts.Token)); + } + + try + { + await Task.WhenAll(Array.ConvertAll(keyed, k => k.Task)).ConfigureAwait(false); + } + catch + { + linkedCts.Cancel(); + try { - // Store error result using a simple string message - try - { - var errorElement = JsonSerializer.SerializeToElement(ex.Message, McpJsonUtilities.JsonContext.Default.String); - await taskStore.StoreTaskResultAsync( - mcpTask.TaskId, - McpTaskStatus.Failed, - errorElement, - SessionId, - CancellationToken.None).ConfigureAwait(false); - - // Update task with error message - var failedTask = await taskStore.UpdateTaskStatusAsync( - mcpTask.TaskId, - McpTaskStatus.Failed, - ex.Message, - SessionId, - CancellationToken.None).ConfigureAwait(false); - - // Send failure notification if enabled - if (sendNotifications) - { - _ = NotifyTaskStatusAsync(failedTask, CancellationToken.None); - } - } - catch - { - // If we can't store the error result, there's not much we can do - } + await Task.WhenAll(Array.ConvertAll(keyed, k => k.Task)).ConfigureAwait(false); } - finally + catch { - // Clean up task cancellation tracking - _taskCancellationTokenProvider!.Complete(mcpTask.TaskId); + // Observed; the original exception is the one we want to surface. } - }, CancellationToken.None); - - // Return the task result immediately - var createTaskResult = new CreateTaskResult { Task = mcpTask }; - return JsonSerializer.SerializeToElement(createTaskResult, McpJsonUtilities.JsonContext.Default.CreateTaskResult); - } - - /// - /// Sends a task status notification to the connected server. - /// - private Task NotifyTaskStatusAsync(McpTask task, CancellationToken cancellationToken) - { - var notificationParams = new McpTaskStatusNotificationParams - { - TaskId = task.TaskId, - Status = task.Status, - StatusMessage = task.StatusMessage, - CreatedAt = task.CreatedAt, - LastUpdatedAt = task.LastUpdatedAt, - TimeToLive = task.TimeToLive, - PollInterval = task.PollInterval - }; + throw; + } - return this.SendNotificationAsync( - NotificationMethods.TaskStatusNotification, - notificationParams, - McpJsonUtilities.JsonContext.Default.McpTaskStatusNotificationParams, - cancellationToken); + var responses = new Dictionary(keyed.Length); + foreach (var (key, task) in keyed) + { + responses[key] = task.Result; + } + return responses; } - /// - /// Registers handlers for task-related requests from the server. - /// - private void RegisterTaskHandlers(RequestHandlers requestHandlers, IMcpTaskStore taskStore) + private async Task ResolveInputRequestAsync(InputRequest inputRequest, CancellationToken cancellationToken) { - // tasks/get handler - Retrieve task status - requestHandlers.Set( - RequestMethods.TasksGet, - async (request, _, cancellationToken) => - { - if (request?.TaskId is not { } taskId) + switch (inputRequest.Method) + { + case RequestMethods.SamplingCreateMessage: + if (_options.Handlers.SamplingHandler is { } samplingHandler) { - throw new McpProtocolException("Missing required parameter 'taskId'", McpErrorCode.InvalidParams); + var samplingParams = inputRequest.SamplingParams + ?? throw new McpException($"Failed to deserialize sampling parameters from MRTR input request."); + var result = await samplingHandler( + samplingParams, + samplingParams.ProgressToken is { } token ? new TokenProgress(this, token) : NullProgress.Instance, + cancellationToken).ConfigureAwait(false); + return InputResponse.FromSamplingResult(result); } - var task = await taskStore.GetTaskAsync(taskId, SessionId, cancellationToken).ConfigureAwait(false); - if (task is null) - { - throw new McpProtocolException($"Task not found: '{taskId}'", McpErrorCode.InvalidParams); - } + throw new InvalidOperationException( + $"Server sent a sampling input request, but no {nameof(McpClientHandlers.SamplingHandler)} is registered."); - return new GetTaskResult + case RequestMethods.ElicitationCreate: + if (_options.Handlers.ElicitationHandler is { } elicitationHandler) { - TaskId = task.TaskId, - Status = task.Status, - StatusMessage = task.StatusMessage, - CreatedAt = task.CreatedAt, - LastUpdatedAt = task.LastUpdatedAt, - TimeToLive = task.TimeToLive, - PollInterval = task.PollInterval - }; - }, - McpJsonUtilities.JsonContext.Default.GetTaskRequestParams, - McpJsonUtilities.JsonContext.Default.GetTaskResult); - - // tasks/result handler - Retrieve task result (blocking until terminal status) - requestHandlers.Set( - RequestMethods.TasksResult, - async (request, _, cancellationToken) => - { - if (request?.TaskId is not { } taskId) - { - throw new McpProtocolException("Missing required parameter 'taskId'", McpErrorCode.InvalidParams); + var elicitParams = inputRequest.ElicitationParams + ?? throw new McpException($"Failed to deserialize elicitation parameters from MRTR input request."); + var result = await elicitationHandler(elicitParams, cancellationToken).ConfigureAwait(false); + result = ElicitResult.WithDefaults(elicitParams, result); + return InputResponse.FromElicitResult(result); } - // Poll until task reaches terminal status - while (true) - { - McpTask? task = await taskStore.GetTaskAsync(taskId, SessionId, cancellationToken).ConfigureAwait(false); - if (task is null) - { - throw new McpProtocolException($"Task not found: '{taskId}'", McpErrorCode.InvalidParams); - } + throw new InvalidOperationException( + $"Server sent an elicitation input request, but no {nameof(McpClientHandlers.ElicitationHandler)} is registered."); - // If terminal, break and retrieve result - if (task.Status is McpTaskStatus.Completed or McpTaskStatus.Failed or McpTaskStatus.Cancelled) - { - break; - } - - // Poll according to task's pollInterval (default 1 second) - var pollInterval = task.PollInterval ?? TimeSpan.FromSeconds(1); - await Task.Delay(pollInterval, cancellationToken).ConfigureAwait(false); - } - - // Retrieve the stored result - return await taskStore.GetTaskResultAsync(taskId, SessionId, cancellationToken).ConfigureAwait(false); - }, - McpJsonUtilities.JsonContext.Default.GetTaskPayloadRequestParams, - McpJsonUtilities.JsonContext.Default.JsonElement); - - // tasks/list handler - List tasks with pagination - requestHandlers.Set( - RequestMethods.TasksList, - async (request, _, cancellationToken) => - { - var cursor = request?.Cursor; - return await taskStore.ListTasksAsync(cursor, SessionId, cancellationToken).ConfigureAwait(false); - }, - McpJsonUtilities.JsonContext.Default.ListTasksRequestParams, - McpJsonUtilities.JsonContext.Default.ListTasksResult); - - // tasks/cancel handler - Cancel a task - requestHandlers.Set( - RequestMethods.TasksCancel, - async (request, _, cancellationToken) => - { - if (request?.TaskId is not { } taskId) + case RequestMethods.RootsList: + if (_options.Handlers.RootsHandler is { } rootsHandler) { - throw new McpProtocolException("Missing required parameter 'taskId'", McpErrorCode.InvalidParams); + // ListRootsRequest params are optional per the spec, so fall back to an empty params instance. + var rootsParams = inputRequest.RootsParams ?? new ListRootsRequestParams(); + var result = await rootsHandler(rootsParams, cancellationToken).ConfigureAwait(false); + return InputResponse.FromRootsResult(result); } - // Signal cancellation if task is still running - _taskCancellationTokenProvider!.Cancel(taskId); + throw new InvalidOperationException( + $"Server sent a roots list input request, but no {nameof(McpClientHandlers.RootsHandler)} is registered."); - var task = await taskStore.CancelTaskAsync(taskId, SessionId, cancellationToken).ConfigureAwait(false); - if (task is null) - { - throw new McpProtocolException($"Task not found: '{taskId}'", McpErrorCode.InvalidParams); - } - - return new CancelMcpTaskResult - { - TaskId = task.TaskId, - Status = task.Status, - StatusMessage = task.StatusMessage, - CreatedAt = task.CreatedAt, - LastUpdatedAt = task.LastUpdatedAt, - TimeToLive = task.TimeToLive, - PollInterval = task.PollInterval - }; - }, - McpJsonUtilities.JsonContext.Default.CancelMcpTaskRequestParams, - McpJsonUtilities.JsonContext.Default.CancelMcpTaskResult); - - // Advertise task capabilities - _options.Capabilities ??= new(); - var tasksCapability = _options.Capabilities.Tasks ??= new McpTasksCapability(); - tasksCapability.List ??= new ListMcpTasksCapability(); - tasksCapability.Cancel ??= new CancelMcpTasksCapability(); - var requestsCapability = tasksCapability.Requests ??= new RequestMcpTasksCapability(); - - // Only advertise sampling tasks if sampling handler is present - if (_options.Handlers.SamplingHandler is not null) - { - var samplingCapability = requestsCapability.Sampling ??= new SamplingMcpTasksCapability(); - samplingCapability.CreateMessage ??= new CreateMessageMcpTasksCapability(); - } - - // Only advertise elicitation tasks if elicitation handler is present - if (_options.Handlers.ElicitationHandler is not null) - { - var elicitationCapability = requestsCapability.Elicitation ??= new ElicitationMcpTasksCapability(); - elicitationCapability.Create ??= new CreateElicitationMcpTasksCapability(); + default: + throw new NotSupportedException($"Unsupported input request method: '{inputRequest.Method}'."); } } - /// - public override string? SessionId => _transport.SessionId; - - /// - public override string? NegotiatedProtocolVersion => _negotiatedProtocolVersion; - - /// - public override ServerCapabilities ServerCapabilities => _serverCapabilities ?? throw new InvalidOperationException("The client is not connected."); - - /// - public override Implementation ServerInfo => _serverInfo ?? throw new InvalidOperationException("The client is not connected."); - - /// - public override string? ServerInstructions => _serverInstructions; - - /// - public override Task Completion => _sessionHandler.CompletionTask; - /// /// Asynchronously connects to an MCP server, establishes the transport connection, and completes the initialization handshake. /// @@ -541,54 +291,199 @@ public async Task ConnectAsync(CancellationToken cancellationToken = default) try { - // Send initialize request - string requestProtocol = _options.ProtocolVersion ?? McpSessionHandler.LatestProtocolVersion; - var initializeResponse = await SendRequestAsync( - RequestMethods.Initialize, - new InitializeRequestParams - { - ProtocolVersion = requestProtocol, - Capabilities = _options.Capabilities ?? new ClientCapabilities(), - ClientInfo = _options.ClientInfo ?? DefaultImplementation, - }, - McpJsonUtilities.JsonContext.Default.InitializeRequestParams, - McpJsonUtilities.JsonContext.Default.InitializeResult, - cancellationToken: initializationCts.Token).ConfigureAwait(false); - - // Store server information - if (_logger.IsEnabled(LogLevel.Information)) + // The 2026-07-28 revision (SEP-2575) is the default: there is no initialize + // handshake. Instead, the client calls server/discover to learn the server's + // capabilities and then begins sending normal RPCs that carry protocolVersion / + // clientInfo / clientCapabilities in their per-request _meta. A null ProtocolVersion + // prefers the 2026-07-28 revision and automatically falls back to the initialize + // handshake when the server doesn't support it. The initialize branch below runs only when + // the caller explicitly pins a version that still supports Streamable HTTP sessions (opting out of the default). + if (_options.ProtocolVersion is null || McpProtocolVersions.RequiresPerRequestMetadata(_options.ProtocolVersion)) { - LogServerCapabilitiesReceived(_endpointName, - capabilities: JsonSerializer.Serialize(initializeResponse.Capabilities, McpJsonUtilities.JsonContext.Default.ServerCapabilities), - serverInfo: JsonSerializer.Serialize(initializeResponse.ServerInfo, McpJsonUtilities.JsonContext.Default.Implementation)); - } + string preferredVersion = _options.ProtocolVersion ?? McpProtocolVersions.July2026ProtocolVersion; + + DiscoverResult? discoverResult = null; + bool fallbackToInitialize = false; + IList? serverSupportedVersions = null; + string discoverVersion = preferredVersion; + + // Apply a probe timeout so dual-path clients don't block forever waiting for an + // initialize-handshake server that silently drops unknown methods (per stdio.mdx fallback rules). + // The probe timeout is configurable via McpClientOptions.DiscoverProbeTimeout and is + // always bounded by InitializationTimeout (only applied when it is the tighter bound). + var probeTimeout = _options.DiscoverProbeTimeout; + using var probeCts = CancellationTokenSource.CreateLinkedTokenSource(initializationCts.Token); + if (_options.InitializationTimeout > probeTimeout) + { + probeCts.CancelAfter(probeTimeout); + } - _serverCapabilities = initializeResponse.Capabilities; - _serverInfo = initializeResponse.ServerInfo; - _serverInstructions = initializeResponse.Instructions; + try + { + discoverResult = await SendDiscoverAsync(discoverVersion, probeCts.Token).ConfigureAwait(false); + } + catch (UnsupportedProtocolVersionException ex) + { + // Spec-recognized SEP-2575 signal: -32022 with data.supported[]. The server is + // refusing our preferred version. Retry with a supported per-request metadata + // version if one exists; otherwise fall back to initialize with the highest + // mutually supported initialize-capable version. + serverSupportedVersions = (IList)ex.Supported; + var retryVersion = serverSupportedVersions + .Where(McpProtocolVersions.PerRequestMetadataProtocolVersions.Contains) + .OrderByDescending(v => v, StringComparer.Ordinal) + .FirstOrDefault(); + + if (retryVersion is not null) + { + if (_options.ProtocolVersion is { } pinnedVersion && + StringComparer.Ordinal.Compare(retryVersion, pinnedVersion) < 0) + { + throw new McpException( + $"The server does not support the requested protocol version '{pinnedVersion}'. " + + "Leave McpClientOptions.ProtocolVersion unset to allow automatic fallback to an older version. " + + $"Server-supported versions: {string.Join(", ", serverSupportedVersions)}."); + } + + discoverVersion = retryVersion; + discoverResult = await SendDiscoverAsync(discoverVersion, probeCts.Token).ConfigureAwait(false); + } + else + { + fallbackToInitialize = true; + } + } + catch (MissingRequiredClientCapabilityException) + { + // Spec-recognized SEP-2575 signal: -32021. The server rejected + // our capability set. Surface as-is (no fallback): the user must add capabilities. + throw; + } + catch (McpProtocolException ex) when (ex.ErrorCode == McpErrorCode.HeaderMismatch) + { + // Spec-recognized SEP-2575 signal: -32020. The server rejected + // our request envelope (e.g., the MCP-Protocol-Version HTTP header didn't match + // the body _meta.io.modelcontextprotocol/protocolVersion). Surface as-is (no + // fallback): falling back to initialize wouldn't fix a malformed envelope. + throw; + } + catch (McpProtocolException ex) when ( + ex.ErrorCode == McpErrorCode.InvalidRequest && + ex.Message.Contains(McpHttpHeaders.SessionId, StringComparison.Ordinal)) + { + // Local transport validation: a 2026-07-28+ response must not carry HTTP session state. + // This is not evidence of an initialize-handshake server, so do not fall back. + throw; + } + catch (McpProtocolException) + { + // Per spec PR #2844, the fallback MUST NOT be keyed to a single error code. + // Any non-SEP-2575 JSON-RPC error from the probe indicates an initialize-handshake server. + // Common causes include MethodNotFound from a server that has no + // server/discover handler, InvalidParams from a server confused by the + // SEP-2575 _meta envelope, ParseError from a server that can't handle our + // payload shape, or any other transport-defined error. The three SEP-2575 + // signals (-32022 UnsupportedProtocolVersion, -32021 + // MissingRequiredClientCapability, -32020 HeaderMismatch) are caught above and + // never reach here. + fallbackToInitialize = true; + } + catch (HttpRequestException ex) when ( + ex.GetStatusCode() is HttpStatusCode.BadRequest or HttpStatusCode.NotFound) + { + // A server predating SEP-2575 can reject the session-less server/discover POST at the + // HTTP layer instead of with a JSON-RPC error: 400 when it cannot parse the request, + // 404 when it requires Mcp-Session-Id on every non-initialize POST. A 400 carrying a + // structured JSON-RPC error is surfaced as McpProtocolException and handled above, so + // anything reaching here is plain or empty. Either way this is an initialize-handshake + // server, so fall back. Other statuses stay uncaught and surface to the caller. + fallbackToInitialize = true; + } + catch (OperationCanceledException) when (probeCts.IsCancellationRequested && !initializationCts.IsCancellationRequested) + { + // Probe timeout elapsed without a response. Per stdio.mdx fallback rules, no + // response within a reasonable timeout means the server requires initialize. Fall back. + fallbackToInitialize = true; + } - // Validate protocol version - bool isResponseProtocolValid = - _options.ProtocolVersion is { } optionsProtocol ? optionsProtocol == initializeResponse.ProtocolVersion : - McpSessionHandler.SupportedProtocolVersions.Contains(initializeResponse.ProtocolVersion); - if (!isResponseProtocolValid) - { - LogServerProtocolVersionMismatch(_endpointName, requestProtocol, initializeResponse.ProtocolVersion); - throw new McpException($"Server protocol version mismatch. Expected {requestProtocol}, got {initializeResponse.ProtocolVersion}"); - } + if (discoverResult is not null && !discoverResult.SupportedVersions.Contains(discoverVersion)) + { + // Server is reachable and supports server/discover, but doesn't support the + // version we are using. Fall back to initialize with the highest + // mutually-supported initialize-capable version from supportedVersions[]. + fallbackToInitialize = true; + serverSupportedVersions = discoverResult.SupportedVersions; + } - _negotiatedProtocolVersion = initializeResponse.ProtocolVersion; + if (fallbackToInitialize) + { + // Reset negotiated state and try initialize. + _negotiatedProtocolVersion = null; + _sessionHandler.NegotiatedProtocolVersion = null; + + string fallbackVersion = serverSupportedVersions? + .Where(McpProtocolVersions.InitializeHandshakeProtocolVersions.Contains) + .OrderByDescending(v => v, StringComparer.Ordinal) + .FirstOrDefault() + ?? McpProtocolVersions.November2025ProtocolVersion; + + // A non-null ProtocolVersion is also the minimum: refuse to fall back below the + // explicitly requested version. String.Compare is the spec's prescribed ordering + // for ISO-8601 date-based versions. + if (_options.ProtocolVersion is { } pinnedVersion && + StringComparer.Ordinal.Compare(fallbackVersion, pinnedVersion) < 0) + { + throw new McpException( + $"The server does not support the requested protocol version '{pinnedVersion}'. " + + "Leave McpClientOptions.ProtocolVersion unset to allow automatic fallback to an older version. " + + (serverSupportedVersions is null + ? "The server appears to require the initialize handshake." + : $"Server-supported versions: {string.Join(", ", serverSupportedVersions)}.")); + } - // Update session handler with the negotiated protocol version for telemetry - _sessionHandler.NegotiatedProtocolVersion = _negotiatedProtocolVersion; + await PerformInitializeHandshakeAsync(fallbackVersion, initializationCts.Token).ConfigureAwait(false); + } + else + { + var discoveredServerInfo = GetServerInfoFromDiscover(discoverResult!); - // Send initialized notification - await this.SendNotificationAsync( - NotificationMethods.InitializedNotification, - new InitializedNotificationParams(), - McpJsonUtilities.JsonContext.Default.InitializedNotificationParams, - cancellationToken: initializationCts.Token).ConfigureAwait(false); + if (_logger.IsEnabled(LogLevel.Information)) + { + LogServerCapabilitiesReceived(_endpointName, + capabilities: JsonSerializer.Serialize(discoverResult!.Capabilities, McpJsonUtilities.JsonContext.Default.ServerCapabilities), + serverInfo: discoveredServerInfo is null + ? "(none)" + : JsonSerializer.Serialize(discoveredServerInfo, McpJsonUtilities.JsonContext.Default.Implementation)); + } + _serverCapabilities = discoverResult!.Capabilities; + _serverInfo = discoveredServerInfo; + _serverInstructions = discoverResult.Instructions; + } + + async Task SendDiscoverAsync(string protocolVersion, CancellationToken cancellationToken) + { + // Eagerly set the negotiated version so InjectRequestMetaIfNeeded recognizes us as being + // on a per-request metadata revision when SendRequestAsync is invoked for server/discover. + _negotiatedProtocolVersion = protocolVersion; + _sessionHandler.NegotiatedProtocolVersion = protocolVersion; + + return await SendRequestAsync( + RequestMethods.ServerDiscover, + new DiscoverRequestParams(), + McpJsonUtilities.JsonContext.Default.DiscoverRequestParams, + McpJsonUtilities.JsonContext.Default.DiscoverResult, + cancellationToken: cancellationToken).ConfigureAwait(false); + } + } + else + { + // initialize handshake. Reached only when the caller explicitly pinned a + // ProtocolVersion that still supports Streamable HTTP sessions (opting out of the default), so + // _options.ProtocolVersion is non-null here. + string requestProtocol = _options.ProtocolVersion ?? McpProtocolVersions.November2025ProtocolVersion; + await PerformInitializeHandshakeAsync(requestProtocol, initializationCts.Token).ConfigureAwait(false); + } } catch (OperationCanceledException oce) when (initializationCts.IsCancellationRequested && !cancellationToken.IsCancellationRequested) { @@ -606,6 +501,88 @@ await this.SendNotificationAsync( LogClientConnected(_endpointName); } + /// + /// Resolves the server identity from a server/discover result. The 2026-07-28 revision carries + /// serverInfo in the result's _meta/io.modelcontextprotocol/serverInfo field rather than + /// the result body. Identity is optional, so a server that omits it yields . + /// + private static Implementation? GetServerInfoFromDiscover(DiscoverResult discoverResult) + { + if (discoverResult.Meta is { } meta && + meta.TryGetPropertyValue(MetaKeys.ServerInfo, out JsonNode? serverInfoNode)) + { + if (serverInfoNode is null) + { + throw new JsonException( + $"Discover result metadata '{MetaKeys.ServerInfo}' must contain a server implementation."); + } + + return JsonSerializer.Deserialize(serverInfoNode, McpJsonUtilities.JsonContext.Default.Implementation) + ?? throw new JsonException( + $"Discover result metadata '{MetaKeys.ServerInfo}' must contain a server implementation."); + } + + return null; + } + + /// + /// Performs the initialize handshake (initialize request + initialized notification), + /// records the negotiated protocol version, and stores the server capabilities/info/instructions. + /// + private async Task PerformInitializeHandshakeAsync(string requestProtocol, CancellationToken cancellationToken) + { + var initializeResponse = await SendRequestAsync( + RequestMethods.Initialize, + new InitializeRequestParams + { + ProtocolVersion = requestProtocol, + Capabilities = _options.Capabilities ?? new ClientCapabilities(), + ClientInfo = _options.ClientInfo ?? DefaultImplementation, + Meta = _options.InitializeMeta, + }, + McpJsonUtilities.JsonContext.Default.InitializeRequestParams, + McpJsonUtilities.JsonContext.Default.InitializeResult, + cancellationToken: cancellationToken).ConfigureAwait(false); + + if (_logger.IsEnabled(LogLevel.Information)) + { + LogServerCapabilitiesReceived(_endpointName, + capabilities: JsonSerializer.Serialize(initializeResponse.Capabilities, McpJsonUtilities.JsonContext.Default.ServerCapabilities), + serverInfo: JsonSerializer.Serialize(initializeResponse.ServerInfo, McpJsonUtilities.JsonContext.Default.Implementation)); + } + + _serverCapabilities = initializeResponse.Capabilities; + _serverInfo = initializeResponse.ServerInfo; + _serverInstructions = initializeResponse.Instructions; + + // When the user explicitly pinned a version that supports Streamable HTTP sessions, the server MUST respect it. + // When no version was pinned, accept any supported initialize-handshake response. initialize cannot negotiate + // the 2026-07-28 and later protocol revisions. + bool isResponseProtocolValid; + if (_options.ProtocolVersion is { } optionsProtocol && !McpProtocolVersions.IsJuly2026OrLaterProtocolVersion(optionsProtocol)) + { + isResponseProtocolValid = optionsProtocol == initializeResponse.ProtocolVersion; + } + else + { + isResponseProtocolValid = McpProtocolVersions.InitializeHandshakeProtocolVersions.Contains(initializeResponse.ProtocolVersion); + } + if (!isResponseProtocolValid) + { + LogServerProtocolVersionMismatch(_endpointName, requestProtocol, initializeResponse.ProtocolVersion); + throw new McpException($"Server protocol version mismatch. Expected {requestProtocol}, got {initializeResponse.ProtocolVersion}"); + } + + _negotiatedProtocolVersion = initializeResponse.ProtocolVersion; + _sessionHandler.NegotiatedProtocolVersion = _negotiatedProtocolVersion; + + await this.SendNotificationAsync( + NotificationMethods.InitializedNotification, + new InitializedNotificationParams(), + McpJsonUtilities.JsonContext.Default.InitializedNotificationParams, + cancellationToken: cancellationToken).ConfigureAwait(false); + } + /// /// Configures the client to use an already initialized session without performing the handshake. /// @@ -623,7 +600,7 @@ internal void ResumeSession(ResumeClientSessionOptions resumeOptions) _serverInstructions = resumeOptions.ServerInstructions; _negotiatedProtocolVersion = resumeOptions.NegotiatedProtocolVersion ?? _options.ProtocolVersion - ?? McpSessionHandler.LatestProtocolVersion; + ?? McpProtocolVersions.November2025ProtocolVersion; // Update session handler with the negotiated protocol version for telemetry _sessionHandler.NegotiatedProtocolVersion = _negotiatedProtocolVersion; @@ -632,8 +609,185 @@ internal void ResumeSession(ResumeClientSessionOptions resumeOptions) } /// - public override Task SendRequestAsync(JsonRpcRequest request, CancellationToken cancellationToken = default) - => _sessionHandler.SendRequestAsync(request, cancellationToken); + public override void AddKnownTools(IEnumerable tools) + { + Throw.IfNull(tools); + + var snapshot = tools as IReadOnlyCollection ?? [.. tools]; + + List? rejections = null; + foreach (var tool in snapshot) + { + Throw.IfNull(tool); + + if (!McpHeaderExtractor.ValidateToolSchema(tool, out var rejectionReason)) + { + ToolRejected?.Invoke(tool, rejectionReason!); + (rejections ??= []).Add($"{tool.Name}: {rejectionReason}"); + } + } + + if (rejections is { Count: > 0 }) + { + throw new ArgumentException( + "One or more tools failed x-mcp-header validation: " + string.Join("; ", rejections), + nameof(tools)); + } + + foreach (var tool in snapshot) + { + _registeredToolNames[tool.Name] = 0; + _toolCache[tool.Name] = tool; + } + } + + /// + public override void RemoveKnownTools(IEnumerable toolNames) + { + Throw.IfNull(toolNames); + + var snapshot = toolNames as IReadOnlyCollection ?? [.. toolNames]; + + foreach (var name in snapshot) + { + Throw.IfNull(name); + } + + foreach (var name in snapshot) + { + _registeredToolNames.TryRemove(name, out _); + _toolCache.TryRemove(name, out _); + } + } + + /// + public override void ClearKnownTools() + { + foreach (var name in _registeredToolNames.Keys) + { + _toolCache.TryRemove(name, out _); + } + + _registeredToolNames.Clear(); + } + + /// + public override async Task SendRequestAsync(JsonRpcRequest request, CancellationToken cancellationToken = default) + { + // For tools/call requests, attach the cached tool definition to the message context + // so the transport can add custom Mcp-Param-* headers based on x-mcp-header schema annotations. + if (request.Method == RequestMethods.ToolsCall && + request.Params is System.Text.Json.Nodes.JsonObject paramsObjForHeaders && + paramsObjForHeaders.TryGetPropertyValue("name", out var nameNode) && + nameNode?.GetValue() is { } toolName) + { + if (_toolCache.TryGetValue(toolName, out var tool)) + { + request.Context ??= new(); + request.Context.Items ??= new Dictionary(); + request.Context.Items[McpHttpHeaders.ToolContextKey] = tool; + } + else if (_transport is StreamableHttpClientSessionTransport) + { + LogToolCacheMiss(toolName); + } + } + + const int maxRetries = 10; + + InjectRequestMetaIfNeeded(request); + + for (int attempt = 0; attempt <= maxRetries; attempt++) + { + JsonRpcResponse response = await _sessionHandler.SendRequestAsync(request, cancellationToken).ConfigureAwait(false); + + // Check if the result is an InputRequiredResult by looking at result_type. + if (response.Result is JsonObject resultObj && + resultObj.TryGetPropertyValue("resultType", out var resultTypeNode) && + resultTypeNode?.GetValue() is "input_required") + { + WarnIfInputRequiredResultOnNonMrtrSession(request.Method); + + var inputRequiredResult = JsonSerializer.Deserialize(response.Result, McpJsonUtilities.JsonContext.Default.InputRequiredResult) + ?? throw new JsonException("Failed to deserialize InputRequiredResult."); + + if (inputRequiredResult.InputRequests is { Count: > 0 } inputRequests) + { + IDictionary inputResponses = + await ResolveInputRequestsAsync(inputRequests, cancellationToken).ConfigureAwait(false); + + // Clone the original request params and add inputResponses + requestState for the retry. + var paramsObj = request.Params?.DeepClone() as JsonObject ?? new JsonObject(); + + paramsObj["inputResponses"] = JsonSerializer.SerializeToNode( + inputResponses, McpJsonUtilities.JsonContext.Default.IDictionaryStringInputResponse); + + if (inputRequiredResult.RequestState is { } requestState) + { + paramsObj["requestState"] = requestState; + } + else + { + // Strip any stale requestState carried over from the previous round's clone so + // the server doesn't see a continuation token the current round is not using. + paramsObj.Remove("requestState"); + } + + request = new JsonRpcRequest { Method = request.Method, Params = paramsObj, Context = request.Context }; + InjectRequestMetaIfNeeded(request); + } + else if (inputRequiredResult.RequestState is not null) + { + // No input requests but has requestState (e.g., load shedding) - just retry with state. + var paramsObj = request.Params?.DeepClone() as JsonObject ?? new JsonObject(); + paramsObj["requestState"] = inputRequiredResult.RequestState; + paramsObj.Remove("inputResponses"); + + request = new JsonRpcRequest { Method = request.Method, Params = paramsObj, Context = request.Context }; + InjectRequestMetaIfNeeded(request); + } + else + { + // An input_required result carrying neither inputRequests nor requestState is + // malformed: there is nothing to resolve and nothing to continue, so retrying the + // unchanged request would just loop until maxRetries. Fail fast instead. + throw new McpException("Server returned an InputRequiredResult without inputRequests or requestState."); + } + + continue; // retry with the updated request + } + + return response; + } + + throw new McpException($"Server returned InputRequiredResult more than {maxRetries} times."); + } + + /// + /// Injects the 2026-07-28 protocol's per-request _meta fields (protocol version, client info, + /// client capabilities) into the request when this client negotiated the 2026-07-28 or later revision + /// (SEP-2575). No-op on an initialize-handshake session. + /// + private void InjectRequestMetaIfNeeded(JsonRpcRequest request) + { + if (!IsJuly2026OrLaterProtocol()) + { + return; + } + + // Initialize is never sent on a 2026-07-28 session, but guard defensively in case a caller + // routes it through here (e.g., during back-compat fallback negotiation). + if (request.Method == RequestMethods.Initialize) + { + return; + } + + McpSessionHandler.InjectRequestMeta( + request, + _negotiatedProtocolVersion!, + _options.ClientInfo ?? DefaultImplementation, + _options.Capabilities ?? new ClientCapabilities()); + } /// public override Task SendMessageAsync(JsonRpcMessage message, CancellationToken cancellationToken = default) @@ -655,7 +809,6 @@ public override async ValueTask DisposeAsync() _disposed = true; - _taskCancellationTokenProvider?.Dispose(); await _sessionHandler.DisposeAsync().ConfigureAwait(false); await _transport.DisposeAsync().ConfigureAwait(false); @@ -668,6 +821,58 @@ public override async ValueTask DisposeAsync() await Completion.ConfigureAwait(false); } + /// Logs a warning if the session negotiated MRTR but the server sent a legacy JSON-RPC request. + private void WarnIfLegacyRequestOnMrtrSession(string method) + { + if (IsJuly2026OrLaterProtocol()) + { + LogLegacyRequestOnMrtrSession(_endpointName, method); + } + } + + /// Logs a warning if the session did not negotiate MRTR but the server sent an InputRequiredResult. + private void WarnIfInputRequiredResultOnNonMrtrSession(string method) + { + if (!IsJuly2026OrLaterProtocol()) + { + LogInputRequiredResultOnNonMrtrSession(_endpointName, method, _negotiatedProtocolVersion); + } + } + + /// + /// Logs a warning (never throws) when a server that negotiated the 2026-07-28 (or later) protocol version + /// omits the SEP-2549 ttlMs/cacheScope fields, which are required on cacheable results for + /// those versions. The warning is emitted at most once per method per session so that paginated listings do + /// not produce one warning per page. + /// + private protected override void ValidateCacheableResult(string method, ICacheableResult result) + { + if (!IsJuly2026OrLaterProtocol()) + { + return; + } + + bool missingTtl = result.TimeToLive is null; + bool missingScope = result.CacheScope is null; + if ((missingTtl || missingScope) && _cacheableConformanceWarnedMethods.TryAdd(method, 0)) + { + string missingFields = + missingTtl && missingScope ? "ttlMs, cacheScope" : + missingTtl ? "ttlMs" : + "cacheScope"; + LogCacheableResultMissingRequiredFields(_endpointName, method, missingFields, _negotiatedProtocolVersion); + } + } + + [LoggerMessage(Level = LogLevel.Warning, Message = "{EndpointName} received '{Method}' result missing required SEP-2549 field(s) '{MissingFields}' from a server that negotiated protocol version '{ProtocolVersion}'. The server may not be spec-compliant.")] + private partial void LogCacheableResultMissingRequiredFields(string endpointName, string method, string missingFields, string? protocolVersion); + + [LoggerMessage(Level = LogLevel.Warning, Message = "{EndpointName} received legacy '{Method}' JSON-RPC request on session that negotiated MRTR. The server should use InputRequiredResult instead of sending direct requests.")] + private partial void LogLegacyRequestOnMrtrSession(string endpointName, string method); + + [LoggerMessage(Level = LogLevel.Warning, Message = "{EndpointName} received InputRequiredResult for '{Method}' on session that did not negotiate MRTR (protocol version '{ProtocolVersion}'). The server may not be spec-compliant.")] + private partial void LogInputRequiredResultOnNonMrtrSession(string endpointName, string method, string? protocolVersion); + [LoggerMessage(Level = LogLevel.Information, Message = "{EndpointName} client received server '{ServerInfo}' capabilities: '{Capabilities}'.")] private partial void LogServerCapabilitiesReceived(string endpointName, string capabilities, string serverInfo); @@ -686,4 +891,9 @@ public override async ValueTask DisposeAsync() [LoggerMessage(Level = LogLevel.Information, Message = "{EndpointName} client resumed existing session.")] private partial void LogClientSessionResumed(string endpointName); + [LoggerMessage(Level = LogLevel.Warning, Message = "Tool '{ToolName}' not found in cache during tools/call. Mcp-Param-* headers will not be sent. Call AddKnownTools or ListToolsAsync to populate the cache.")] + private partial void LogToolCacheMiss(string toolName); + + [LoggerMessage(Level = LogLevel.Warning, Message = "Tool '{ToolName}' excluded from tools/list: {Reason}")] + private partial void LogToolRejected(string toolName, string reason); } diff --git a/src/ModelContextProtocol.Core/Client/McpClientOptions.cs b/src/ModelContextProtocol.Core/Client/McpClientOptions.cs index 6d91f5b03..61a0613df 100644 --- a/src/ModelContextProtocol.Core/Client/McpClientOptions.cs +++ b/src/ModelContextProtocol.Core/Client/McpClientOptions.cs @@ -1,5 +1,6 @@ using ModelContextProtocol.Protocol; using System.Diagnostics.CodeAnalysis; +using System.Text.Json.Nodes; namespace ModelContextProtocol.Client; @@ -31,19 +32,43 @@ public sealed class McpClientOptions /// public ClientCapabilities? Capabilities { get; set; } + /// + /// Gets or sets the metadata to include in the _meta field of the request. + /// + /// + /// + /// When set, this value is sent as on the during the initialization handshake. + /// This allows passing implementation-specific data to the server alongside the standard initialize parameters, + /// such as authentication context a server validates before completing the handshake. + /// + /// + /// When , no _meta field is sent. + /// + /// + public JsonObject? InitializeMeta { get; set; } + /// /// Gets or sets the protocol version to request from the server, using a date-based versioning scheme. /// /// /// - /// The protocol version is a key part of the initialization handshake. The client and server must - /// agree on a compatible protocol version to communicate successfully. + /// Supported values are 2024-11-05, 2025-03-26, 2025-06-18, 2025-11-25, + /// and 2026-07-28. + /// + /// + /// When (the default), the client prefers the latest revision (2026-07-28), + /// which removed the initialize handshake and Streamable HTTP sessions. It probes with + /// server/discover and automatically falls back to the initialize handshake, + /// downgrading to an initialize-capable version the server advertises, when the server does not support that revision. /// /// - /// If non-, this version will be sent to the server, and the handshake - /// will fail if the version in the server's response does not match this version. - /// If , the client will request the latest version supported by the server - /// but will allow any supported version that the server advertises in its response. + /// When non-, this value is both the requested version and the minimum the client + /// will accept: the client requests exactly this version and refuses to downgrade below it, throwing an + /// instead of falling back. Setting it to 2026-07-28 therefore disables + /// the automatic initialize-handshake server fallback, and setting it to a version that still supports Streamable HTTP + /// sessions, such as 2025-11-25, forces the initialize handshake and fails if the server + /// negotiates a different version. To try more than one version, leave this unset for automatic fallback + /// or retry the connection with a different value. /// /// public string? ProtocolVersion { get; set; } @@ -67,6 +92,52 @@ public sealed class McpClientOptions /// public TimeSpan InitializationTimeout { get; set; } = TimeSpan.FromSeconds(60); + /// + /// Gets or sets the timeout applied to the server/discover probe that the client issues + /// before falling back to the initialize handshake. + /// + /// + /// The probe timeout. The default value is 5 seconds. Use + /// to disable the separate probe timeout + /// and rely solely on . + /// + /// + /// + /// This timeout only has an effect when the client prefers the 2026-07-28 protocol revision, that is, + /// when is (the default) or 2026-07-28. + /// In that mode the client first probes the server with a + /// server/discover request. A server that predates the 2026-07-28 revision may + /// silently drop the unknown method, so the probe is bounded by this timeout; when it elapses the + /// client concludes the server requires initialize and falls back to that handshake on the + /// same connection. When the caller pins an initialize-capable , no probe is issued + /// and this value has no effect. + /// + /// + /// The default is intentionally short so that dual-path clients fall back quickly against initialize-handshake + /// servers. Increase it for high-latency environments (for example, cold-start serverless peers or + /// satellite links) where a short probe could trigger the initialize fallback before a server on the + /// per-request metadata revision has had a chance to respond. The probe is always also bounded by + /// , which governs the overall connect budget: if this value is + /// greater than or equal to , the probe is effectively bounded by + /// alone. + /// + /// + /// + /// The value is not positive and is not . + /// + public TimeSpan DiscoverProbeTimeout + { + get; + set + { + if (value <= TimeSpan.Zero && value != Timeout.InfiniteTimeSpan) + { + throw new ArgumentOutOfRangeException(nameof(value), value, "must be positive or Timeout.InfiniteTimeSpan."); + } + field = value; + } + } = TimeSpan.FromSeconds(5); + /// /// Gets or sets the container of handlers used by the client for processing protocol messages. /// @@ -80,35 +151,4 @@ public McpClientHandlers Handlers } } - /// - /// Gets or sets the task store for managing client-side tasks. - /// - /// - /// - /// When a task store is configured, the client will support task-augmented requests from the server. - /// This allows the server to request sampling or elicitation as tasks, which the client executes - /// asynchronously and allows the server to poll for status and results. - /// - /// - /// If not set, task-augmented requests will not be supported, and the client will not advertise - /// task capabilities to the server. - /// - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - public IMcpTaskStore? TaskStore { get; set; } - - /// - /// Gets or sets a value indicating whether the client should send task status notifications to the server. - /// - /// - /// to send task status notifications; otherwise. - /// The default is . - /// - /// - /// When enabled and a is configured, the client will send optional - /// notifications/tasks/status notifications to inform the server of task state changes. - /// Servers MUST NOT rely on receiving these notifications and should continue polling via tasks/get. - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - public bool SendTaskStatusNotifications { get; set; } = true; } diff --git a/src/ModelContextProtocol.Core/Client/McpClientTool.cs b/src/ModelContextProtocol.Core/Client/McpClientTool.cs index 6a378caa9..f9d353e8c 100644 --- a/src/ModelContextProtocol.Core/Client/McpClientTool.cs +++ b/src/ModelContextProtocol.Core/Client/McpClientTool.cs @@ -135,7 +135,7 @@ internal McpClientTool( // would lose that information. So, we only do the translation if there is no additional information to preserve. if (result.IsError is not true && result.StructuredContent is null && - result.Meta is not { Count: > 0 }) + !HasApplicationResultMetadata(result.Meta)) { switch (result.Content.Count) { @@ -150,6 +150,26 @@ result.StructuredContent is null && return JsonSerializer.SerializeToElement(result, McpJsonUtilities.JsonContext.Default.CallToolResult); } + private static bool HasApplicationResultMetadata(JsonObject? meta) + { + if (meta is null) + { + return false; + } + + foreach (var property in meta) + { + // Server identity is protocol metadata already exposed through McpClient.ServerInfo. + // It should not force an otherwise simple tool result into its JSON envelope. + if (!string.Equals(property.Key, MetaKeys.ServerInfo, StringComparison.Ordinal)) + { + return true; + } + } + + return false; + } + /// /// Invokes the tool on the server. /// diff --git a/src/ModelContextProtocol.Core/Client/McpHeaderExtractor.cs b/src/ModelContextProtocol.Core/Client/McpHeaderExtractor.cs new file mode 100644 index 000000000..99fe5462a --- /dev/null +++ b/src/ModelContextProtocol.Core/Client/McpHeaderExtractor.cs @@ -0,0 +1,403 @@ +using System.Net.Http.Headers; +using System.Globalization; +using System.Text.Json; +#if NET +using System.Buffers; +#endif +using Microsoft.Extensions.Logging; +using ModelContextProtocol.Protocol; + +namespace ModelContextProtocol.Client; + +/// +/// Extracts parameter values from tool call arguments and adds them as HTTP headers +/// based on x-mcp-header schema extensions. +/// +internal static class McpHeaderExtractor +{ + private const string XMcpHeaderProperty = "x-mcp-header"; + + /// + /// Adds custom parameter headers to an HTTP request based on a tool's schema extensions. + /// + /// The HTTP request headers to add to. + /// The tool definition containing the input schema with x-mcp-header annotations. + /// The arguments being passed to the tool call. + public static void AddParameterHeaders( + HttpRequestHeaders headers, + Tool tool, + JsonElement? arguments) + { + if (!arguments.HasValue || arguments.Value.ValueKind != JsonValueKind.Object) + { + return; + } + + if (tool.InputSchema.ValueKind != JsonValueKind.Object || + !tool.InputSchema.TryGetProperty("properties", out var properties) || + properties.ValueKind != JsonValueKind.Object) + { + return; + } + + AddParameterHeadersFromProperties(headers, properties, arguments.Value); + } + + /// + /// Recursively extracts parameter values from properties at any nesting depth + /// and adds them as HTTP headers. + /// + private static void AddParameterHeadersFromProperties( + HttpRequestHeaders headers, + JsonElement properties, + JsonElement arguments) + { + foreach (var property in properties.EnumerateObject()) + { + if (property.Value.ValueKind != JsonValueKind.Object) + { + continue; + } + + // Recurse into nested object properties + if (property.Value.TryGetProperty("properties", out var nestedProperties) && + nestedProperties.ValueKind == JsonValueKind.Object && + arguments.TryGetProperty(property.Name, out var nestedArgs) && + nestedArgs.ValueKind == JsonValueKind.Object) + { + AddParameterHeadersFromProperties(headers, nestedProperties, nestedArgs); + } + + if (!property.Value.TryGetProperty(XMcpHeaderProperty, out var headerNameElement)) + { + continue; + } + + var headerName = headerNameElement.GetString(); + if (string.IsNullOrEmpty(headerName)) + { + continue; + } + + // Look for the corresponding argument value + if (!arguments.TryGetProperty(property.Name, out var argValue)) + { + continue; + } + + // Null values → omit header per SEP + if (argValue.ValueKind == JsonValueKind.Null) + { + continue; + } + + var headerValue = ConvertArgumentToHeaderValue(property.Value, property.Name, argValue); + if (headerValue is not null) + { + headers.Add($"{McpHttpHeaders.ParamPrefix}{headerName}", headerValue); + } + } + } + + // The maximum magnitude for an integer that can be represented exactly by an IEEE 754 + // double-precision value (2^53 - 1). Per SEP-2243 integer x-mcp-header values MUST be within + // the JavaScript safe integer range (-2^53+1 to 2^53-1) so intermediaries can compare them. + private const long MaxSafeInteger = 9007199254740991L; + + /// + /// Converts an argument value to its encoded header representation. When the property schema + /// declares an integer type, the value is canonicalized to its decimal string form + /// (e.g. a body value of 42.0 is emitted as "42") per SEP-2243. + /// + private static string? ConvertArgumentToHeaderValue(JsonElement propertySchema, string propertyName, JsonElement argValue) + { + if (argValue.ValueKind == JsonValueKind.Number && SchemaTypeIsInteger(propertySchema)) + { + if (!TryGetCanonicalSafeInteger(argValue, out long canonical)) + { + throw new McpException( + $"The value '{argValue.GetRawText()}' for parameter '{propertyName}' annotated with x-mcp-header " + + $"is not a whole number within the JavaScript safe integer range (-{MaxSafeInteger} to {MaxSafeInteger})."); + } + + return McpHeaderEncoder.EncodeValue(canonical); + } + + return McpHeaderEncoder.ConvertToHeaderValue(argValue); + } + + /// + /// Determines whether the property schema's type keyword declares an integer type, + /// either directly or as a member of a JSON Schema union array (e.g. ["integer", "null"]). + /// + private static bool SchemaTypeIsInteger(JsonElement propertySchema) + { + if (!propertySchema.TryGetProperty("type", out var typeElement)) + { + return false; + } + + switch (typeElement.ValueKind) + { + case JsonValueKind.String: + return typeElement.ValueEquals("integer"); + + case JsonValueKind.Array: + foreach (var entry in typeElement.EnumerateArray()) + { + if (entry.ValueKind == JsonValueKind.String && entry.ValueEquals("integer")) + { + return true; + } + } + + return false; + + default: + return false; + } + } + + /// + /// Attempts to interpret a JSON number as a whole integer within the JavaScript safe integer + /// range. Decimal and exponent forms whose fractional part is zero (e.g. 42.0, 4.2e1) + /// are accepted; non-integers and out-of-range values are rejected. + /// + private static bool TryGetCanonicalSafeInteger(JsonElement element, out long value) + { + if (element.TryGetInt64(out value)) + { + return value >= -MaxSafeInteger && value <= MaxSafeInteger; + } + + // Handle decimal/exponent representations of whole numbers such as "42.0" or "4.2e1". + // long.TryParse inspects the actual digits (so non-integers such as "42.5" are rejected + // without rounding) and fails fast on overflow (no large-number allocation). + const NumberStyles Styles = NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent; + if (long.TryParse(element.GetRawText(), Styles, CultureInfo.InvariantCulture, out long parsed) && + parsed >= -MaxSafeInteger && parsed <= MaxSafeInteger) + { + value = parsed; + return true; + } + + value = 0; + return false; + } + + /// + /// Validates a tool's inputSchema for valid x-mcp-header annotations. + /// Returns if the tool is valid; with a reason if it should be rejected. + /// + internal static bool ValidateToolSchema(Tool tool, out string? rejectionReason) + { + rejectionReason = null; + + if (tool.InputSchema.ValueKind != JsonValueKind.Object || + !tool.InputSchema.TryGetProperty("properties", out var properties) || + properties.ValueKind != JsonValueKind.Object) + { + return true; + } + + var headerNames = new HashSet(StringComparer.OrdinalIgnoreCase); + return ValidateProperties(tool, properties, headerNames, out rejectionReason); + } + + /// + /// Recursively validates properties at any nesting depth for valid x-mcp-header annotations. + /// + private static bool ValidateProperties(Tool tool, JsonElement properties, HashSet headerNames, out string? rejectionReason) + { + rejectionReason = null; + + foreach (var property in properties.EnumerateObject()) + { + // Skip properties whose schema is not an object (e.g., boolean `true`/`false` schemas) + if (property.Value.ValueKind != JsonValueKind.Object) + { + continue; + } + + // Recurse into nested object properties + if (property.Value.TryGetProperty("properties", out var nestedProperties) && + nestedProperties.ValueKind == JsonValueKind.Object) + { + if (!ValidateProperties(tool, nestedProperties, headerNames, out rejectionReason)) + { + return false; + } + } + + if (!property.Value.TryGetProperty(XMcpHeaderProperty, out var headerNameElement)) + { + continue; + } + + // x-mcp-header value must be a string + if (headerNameElement.ValueKind != JsonValueKind.String) + { + rejectionReason = $"Tool '{tool.Name}': x-mcp-header on property '{property.Name}' is not a string."; + return false; + } + + var headerName = headerNameElement.GetString(); + + // MUST NOT be empty + if (string.IsNullOrEmpty(headerName)) + { + rejectionReason = $"Tool '{tool.Name}': x-mcp-header on property '{property.Name}' is empty."; + return false; + } + + // MUST match HTTP field-name token syntax (1*tchar, RFC 9110 Section 5.1) + // MUST NOT contain control characters including CR and LF + int invalidIdx = FindFirstNonTchar(headerName!); + if (invalidIdx >= 0) + { + char c = headerName![invalidIdx]; + rejectionReason = $"Tool '{tool.Name}': x-mcp-header '{headerName}' contains invalid character '{c}' (0x{(int)c:X2})."; + return false; + } + + // MUST be case-insensitively unique + if (!headerNames.Add(headerName!)) + { + rejectionReason = $"Tool '{tool.Name}': duplicate x-mcp-header name '{headerName}' (case-insensitive)."; + return false; + } + + // MUST only be applied to parameters with primitive types (string, integer, boolean). + // Parameters with type "number" (or any other non-primitive type) are not permitted. + // The "type" keyword may be omitted (treated as unknown, not rejected, since many valid + // schemas constrain the value via enum/const/$ref instead) or expressed as a JSON Schema + // union array such as ["string", "null"]; only an explicitly disallowed or malformed type + // causes rejection. + if (property.Value.TryGetProperty("type", out var typeElement) && + !IsAllowedHeaderType(typeElement)) + { + rejectionReason = $"Tool '{tool.Name}': x-mcp-header on property '{property.Name}' has unsupported type '{typeElement}'. Only 'string', 'integer', and 'boolean' are allowed."; + return false; + } + } + + return true; + } + + /// + /// Determines whether a JSON Schema type keyword is compatible with x-mcp-header, + /// which per SEP-2243 may only be applied to string, integer, or boolean + /// parameters. A union array (e.g., ["string", "null"]) is allowed as long as it contains + /// at least one allowed primitive; "null" is tolerated only as an additional union member. + /// Any other shape (a disallowed type name, a non-string array element, an empty array, or a + /// non-string/non-array value) is treated as incompatible. + /// + private static bool IsAllowedHeaderType(JsonElement typeElement) + { + switch (typeElement.ValueKind) + { + case JsonValueKind.String: + return IsAllowedPrimitiveTypeName(typeElement.GetString()); + + case JsonValueKind.Array: + bool hasAllowedPrimitive = false; + foreach (var entry in typeElement.EnumerateArray()) + { + if (entry.ValueKind != JsonValueKind.String) + { + return false; + } + + var entryName = entry.GetString(); + if (entryName == "null") + { + continue; + } + + if (!IsAllowedPrimitiveTypeName(entryName)) + { + return false; + } + + hasAllowedPrimitive = true; + } + + return hasAllowedPrimitive; + + default: + // A "type" that is present but is neither a string nor an array of strings is malformed. + return false; + } + } + + private static bool IsAllowedPrimitiveTypeName(string? typeName) => + typeName is "string" or "integer" or "boolean"; + + // Valid HTTP token characters (tchar) per RFC 9110 Section 5.6.2: + // tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." / + // "^" / "_" / "`" / "|" / "~" / DIGIT / ALPHA + private const string TcharChars = "!#$%&'*+-.^_`|~0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; + +#if NET + private static readonly SearchValues s_tcharValues = SearchValues.Create(TcharChars); + + internal static int FindFirstNonTchar(string value) => + value.AsSpan().IndexOfAnyExcept(s_tcharValues); +#else + // Bitmap for O(1) tchar lookup. All valid chars are in 0x21-0x7E range, + // so two ulongs (128 bits) cover the entire ASCII range. + // _tcharBitmapLo covers chars 0-63, _tcharBitmapHi covers chars 64-127. + private static readonly ulong s_tcharBitmapLo = ComputeBitmapLo(); + private static readonly ulong s_tcharBitmapHi = ComputeBitmapHi(); + + private static ulong ComputeBitmapLo() + { + ulong bitmap = 0; + foreach (char c in TcharChars) + { + if (c < 64) + { + bitmap |= 1UL << c; + } + } + return bitmap; + } + + private static ulong ComputeBitmapHi() + { + ulong bitmap = 0; + foreach (char c in TcharChars) + { + if (c >= 64) + { + bitmap |= 1UL << (c - 64); + } + } + return bitmap; + } + + private static bool IsTchar(char c) + { + if (c >= 128) + { + return false; + } + + return c < 64 + ? (s_tcharBitmapLo & (1UL << c)) != 0 + : (s_tcharBitmapHi & (1UL << (c - 64))) != 0; + } + + internal static int FindFirstNonTchar(string value) + { + for (int i = 0; i < value.Length; i++) + { + if (!IsTchar(value[i])) + { + return i; + } + } + return -1; + } +#endif +} diff --git a/src/ModelContextProtocol.Core/Client/McpHttpClient.cs b/src/ModelContextProtocol.Core/Client/McpHttpClient.cs index 7caf50143..f4df789c7 100644 --- a/src/ModelContextProtocol.Core/Client/McpHttpClient.cs +++ b/src/ModelContextProtocol.Core/Client/McpHttpClient.cs @@ -12,7 +12,7 @@ namespace ModelContextProtocol.Client; internal class McpHttpClient(HttpClient httpClient) { - internal static readonly MediaTypeHeaderValue s_applicationJsonContentType = new("application/json") { CharSet = "utf-8" }; + internal static readonly MediaTypeHeaderValue s_applicationJsonContentType = new("application/json"); internal virtual async Task SendAsync(HttpRequestMessage request, JsonRpcMessage? message, CancellationToken cancellationToken) { @@ -32,7 +32,7 @@ internal virtual async Task SendAsync(HttpRequestMessage re } #if NET - return JsonContent.Create(message, McpJsonUtilities.JsonContext.Default.JsonRpcMessage); + return JsonContent.Create(message, McpJsonUtilities.JsonContext.Default.JsonRpcMessage, s_applicationJsonContentType); #else var bytes = JsonSerializer.SerializeToUtf8Bytes(message, McpJsonUtilities.JsonContext.Default.JsonRpcMessage); var content = new ByteArrayContent(bytes); diff --git a/src/ModelContextProtocol.Core/Client/SseClientSessionTransport.cs b/src/ModelContextProtocol.Core/Client/SseClientSessionTransport.cs index fb918989b..99bdc1eb9 100644 --- a/src/ModelContextProtocol.Core/Client/SseClientSessionTransport.cs +++ b/src/ModelContextProtocol.Core/Client/SseClientSessionTransport.cs @@ -23,6 +23,7 @@ internal sealed partial class SseClientSessionTransport : TransportBase private Task? _receiveTask; private readonly ILogger _logger; private readonly TaskCompletionSource _connectionEstablished; + private volatile bool _sseAdopted; /// /// SSE transport for a single session. Unlike stdio it does not launch a process, but connects to an existing server. @@ -66,7 +67,7 @@ public async Task ConnectAsync(CancellationToken cancellationToken = default) { LogTransportConnectFailed(Name, ex); await CloseAsync().ConfigureAwait(false); - throw new IOException("Failed to connect transport.", ex); + throw; } } @@ -107,6 +108,8 @@ public override async Task SendMessageAsync( throw HttpResponseMessageExtensions.CreateHttpRequestException(response, responseBody); } + + _sseAdopted = true; } private async Task CloseAsync() @@ -129,7 +132,7 @@ private async Task CloseAsync() } finally { - SetDisconnected(new ClientTransportClosedException(new HttpClientCompletionDetails())); + SetSseDisconnected(new ClientTransportClosedException(new HttpClientCompletionDetails())); } } @@ -190,7 +193,7 @@ private async Task ReceiveMessagesAsync(CancellationToken cancellationToken) } else { - SetDisconnected(new ClientTransportClosedException(new HttpClientCompletionDetails + SetSseDisconnected(new ClientTransportClosedException(new HttpClientCompletionDetails { HttpStatusCode = failureStatusCode, Exception = ex, @@ -198,12 +201,22 @@ private async Task ReceiveMessagesAsync(CancellationToken cancellationToken) LogTransportReadMessagesFailed(Name, ex); _connectionEstablished.TrySetException(ex); - throw; } } finally { - SetDisconnected(new ClientTransportClosedException(new HttpClientCompletionDetails())); + SetSseDisconnected(new ClientTransportClosedException(new HttpClientCompletionDetails())); + } + } + + private void SetSseDisconnected(Exception error) + { + // If AutoDetect is still probing SSE, leave its shared message channel open so it can + // retry with another transport. A successful POST means SSE was selected and owns the + // channel from that point on, matching Streamable HTTP's adoption behavior. + if (_options.TransportMode is not HttpTransportMode.AutoDetect || _sseAdopted) + { + SetDisconnected(error); } } diff --git a/src/ModelContextProtocol.Core/Client/StdioClientTransport.cs b/src/ModelContextProtocol.Core/Client/StdioClientTransport.cs index 24a7dba8e..2e44ee34f 100644 --- a/src/ModelContextProtocol.Core/Client/StdioClientTransport.cs +++ b/src/ModelContextProtocol.Core/Client/StdioClientTransport.cs @@ -111,6 +111,11 @@ public async Task ConnectAsync(CancellationToken cancellationToken = #endif } + if (!_options.InheritEnvironmentVariables) + { + startInfo.Environment.Clear(); + } + if (_options.EnvironmentVariables != null) { foreach (var entry in _options.EnvironmentVariables) @@ -121,9 +126,8 @@ public async Task ConnectAsync(CancellationToken cancellationToken = if (logger.IsEnabled(LogLevel.Trace)) { - LogCreateProcessForTransportSensitive(logger, endpointName, _options.Command, + LogCreateProcessForTransportDetailed(logger, endpointName, _options.Command, startInfo.Arguments, - string.Join(", ", startInfo.Environment.Select(kvp => $"{kvp.Key}={kvp.Value}")), startInfo.WorkingDirectory); } else @@ -183,14 +187,29 @@ public async Task ConnectAsync(CancellationToken cancellationToken = lock (s_consoleEncodingLock) { Encoding originalInputEncoding = Console.InputEncoding; + bool encodingChanged = false; try { - Console.InputEncoding = StreamClientSessionTransport.NoBomUtf8Encoding; + try + { + Console.InputEncoding = StreamClientSessionTransport.NoBomUtf8Encoding; + encodingChanged = true; + } + catch + { + // Host has no usable console (e.g. WPF/WinForms on .NET Framework with no + // AllocConsole). The child inherits the current Console.InputEncoding; + // non-ASCII stdin may be misencoded, but the connect itself proceeds. + } + processStarted = process.Start(); } finally { - Console.InputEncoding = originalInputEncoding; + if (encodingChanged) + { + Console.InputEncoding = originalInputEncoding; + } } } #endif @@ -295,8 +314,8 @@ private static string EscapeArgumentString(string argument) => [LoggerMessage(Level = LogLevel.Information, Message = "{EndpointName} starting server process. Command: '{Command}'.")] private static partial void LogCreateProcessForTransport(ILogger logger, string endpointName, string command); - [LoggerMessage(Level = LogLevel.Trace, Message = "{EndpointName} starting server process. Command: '{Command}', Arguments: {Arguments}, Environment: {Environment}, Working directory: {WorkingDirectory}.")] - private static partial void LogCreateProcessForTransportSensitive(ILogger logger, string endpointName, string command, string? arguments, string environment, string workingDirectory); + [LoggerMessage(Level = LogLevel.Trace, Message = "{EndpointName} starting server process. Command: '{Command}', Arguments: {Arguments}, Working directory: {WorkingDirectory}.")] + private static partial void LogCreateProcessForTransportDetailed(ILogger logger, string endpointName, string command, string? arguments, string workingDirectory); [LoggerMessage(Level = LogLevel.Warning, Message = "{EndpointName} failed to start server process.")] private static partial void LogTransportProcessStartFailed(ILogger logger, string endpointName); diff --git a/src/ModelContextProtocol.Core/Client/StdioClientTransportOptions.cs b/src/ModelContextProtocol.Core/Client/StdioClientTransportOptions.cs index 2d6df08b4..6fe171dff 100644 --- a/src/ModelContextProtocol.Core/Client/StdioClientTransportOptions.cs +++ b/src/ModelContextProtocol.Core/Client/StdioClientTransportOptions.cs @@ -1,3 +1,5 @@ +using System.Runtime.InteropServices; + namespace ModelContextProtocol.Client; /// @@ -5,6 +7,90 @@ namespace ModelContextProtocol.Client; /// public sealed class StdioClientTransportOptions { + // Platform-appropriate allowlists, aligned with the TypeScript and Python MCP SDK defaults. + // TypeScript adds PROGRAMFILES; Python adds PATHEXT. Both are included here. + private static readonly string[] s_defaultWindowsVars = + [ + "APPDATA", "HOMEDRIVE", "HOMEPATH", "LOCALAPPDATA", "PATH", "PATHEXT", + "PROCESSOR_ARCHITECTURE", "PROGRAMFILES", "SYSTEMDRIVE", "SYSTEMROOT", + "TEMP", "USERNAME", "USERPROFILE", + ]; + + private static readonly string[] s_defaultUnixVars = + [ + "HOME", "LOGNAME", "PATH", "SHELL", "TERM", "USER", + ]; + + /// + /// Returns a curated set of environment variables from the current process that are safe to forward to a child + /// MCP server process. + /// + /// + /// A new populated with the subset of the current process's environment + /// variables that most child processes need to start correctly — for example PATH, HOME, and + /// standard system directories. Values that appear to be shell function definitions (those starting with + /// ()) are excluded for security reasons. + /// + /// + /// + /// The allowlist is aligned with the defaults used by the TypeScript and Python MCP SDKs. On Windows it + /// includes: APPDATA, HOMEDRIVE, HOMEPATH, LOCALAPPDATA, PATH, + /// PATHEXT, PROCESSOR_ARCHITECTURE, PROGRAMFILES, SYSTEMDRIVE, + /// SYSTEMROOT, TEMP, USERNAME, and USERPROFILE. On Unix/macOS it includes: + /// HOME, LOGNAME, PATH, SHELL, TERM, and USER. + /// + /// + /// This method is designed to be used together with set to + /// . Pass the returned dictionary as , optionally + /// adding any server-specific variables the server requires: + /// + /// var env = StdioClientTransportOptions.GetDefaultEnvironmentVariables(); + /// env["MY_SERVER_API_KEY"] = apiKey; + /// + /// var transport = new StdioClientTransport(new StdioClientTransportOptions + /// { + /// Command = "my-mcp-server", + /// InheritEnvironmentVariables = false, + /// EnvironmentVariables = env, + /// }); + /// + /// + /// + /// If the server requires additional variables not in the default set (such as DOTNET_ROOT, + /// JAVA_HOME, or proxy settings), add them explicitly after calling this method. + /// + /// + public static Dictionary GetDefaultEnvironmentVariables() + { + var names = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) + ? s_defaultWindowsVars + : s_defaultUnixVars; + + var result = new Dictionary( + RuntimeInformation.IsOSPlatform(OSPlatform.Windows) + ? StringComparer.OrdinalIgnoreCase + : StringComparer.Ordinal); + foreach (var name in names) + { + var value = Environment.GetEnvironmentVariable(name); + if (value is null) + { + continue; + } + + if (value.StartsWith("()", StringComparison.Ordinal)) + { + // Skip shell function definitions — they are a security risk. + continue; + } + + result[name] = value; + } + + return result; + } + + /// /// Gets or sets the command to execute to start the server process. /// @@ -38,6 +124,44 @@ public required string Command /// public string? WorkingDirectory { get; set; } + /// + /// Gets or sets a value indicating whether the server process should inherit the current process's environment variables. + /// + /// + /// to inherit the current process's environment variables (the default); + /// to start the server process with an empty environment and only the variables explicitly provided via + /// . + /// + /// + /// + /// When (the default), the server process starts with all of the current process's environment + /// variables. Any entries in are then applied on top, adding or overwriting inherited + /// variables. + /// + /// + /// When , the server process starts with a completely empty environment. The + /// dictionary is the sole source of environment variables for the child process. This is useful when you want to minimize + /// the attack surface by preventing credentials, tokens, proxy settings, and other sensitive values present in the current + /// environment from unintentionally reaching the child process. + /// + /// + /// Security consideration: Inheriting environment variables (the default) can unintentionally expose + /// sensitive values to the child process. Variables such as AWS_SECRET_ACCESS_KEY, GITHUB_TOKEN, + /// OPENAI_API_KEY, and similar credentials that are present in the parent process will automatically flow into + /// the server process, which may be undesirable when running third-party or untrusted MCP servers. + /// + /// + /// Compatibility consideration: Disabling inheritance can cause the child process to fail to start or + /// behave unexpectedly if it relies on variables provided by the operating system or the user's shell environment. + /// covers the most common requirements — PATH, HOME, and + /// standard system directories — and is a safe starting point for most servers. For servers that also need variables + /// outside that set (such as DOTNET_ROOT, LD_LIBRARY_PATH, JAVA_HOME, or proxy settings like + /// HTTP_PROXY, HTTPS_PROXY, and NO_PROXY), add them explicitly via + /// after calling . + /// + /// + public bool InheritEnvironmentVariables { get; set; } = true; + /// /// Gets or sets environment variables to set for the server process. /// @@ -48,10 +172,14 @@ public required string Command /// to the server without modifying its code. /// /// - /// By default, when starting the server process, the server process will inherit the current environment's variables, - /// as discovered via . After those variables are found, the entries - /// in this dictionary are used to augment and overwrite the entries read from the environment. - /// That includes removing the variables for any of this collection's entries with a null value. + /// When is (the default), the server process starts with + /// all environment variables inherited from the current process. The entries in this + /// dictionary are then applied on top: adding new variables, overwriting inherited ones, or removing variables whose + /// value is set to . + /// + /// + /// When is , the server process starts with an empty + /// environment. This dictionary is the sole source of environment variables for the child process. /// /// public IDictionary? EnvironmentVariables { get; set; } diff --git a/src/ModelContextProtocol.Core/Client/StreamableHttpClientSessionTransport.cs b/src/ModelContextProtocol.Core/Client/StreamableHttpClientSessionTransport.cs index f51e236b4..db67b2e6b 100644 --- a/src/ModelContextProtocol.Core/Client/StreamableHttpClientSessionTransport.cs +++ b/src/ModelContextProtocol.Core/Client/StreamableHttpClientSessionTransport.cs @@ -4,6 +4,7 @@ using System.Net.Http.Headers; using System.Net.ServerSentEvents; using System.Text.Json; +using System.Text.Json.Nodes; using ModelContextProtocol.Protocol; using System.Threading.Channels; using System.Net; @@ -25,6 +26,7 @@ internal sealed partial class StreamableHttpClientSessionTransport : TransportBa private string? _negotiatedProtocolVersion; private Task? _getReceiveTask; + private bool _streamableHttpAdopted; private volatile ClientTransportClosedException? _disconnectError; private readonly SemaphoreSlim _disposeLock = new(1, 1); @@ -53,7 +55,8 @@ public StreamableHttpClientSessionTransport( if (_options.KnownSessionId is { } knownSessionId) { SessionId = knownSessionId; - _getReceiveTask = ReceiveUnsolicitedMessagesAsync(); + _streamableHttpAdopted = true; + StartUnsolicitedMessageStreamIfEnabled(); } } @@ -62,9 +65,74 @@ public override async Task SendMessageAsync(JsonRpcMessage message, Cancellation { // Immediately dispose the response. SendHttpRequestAsync only returns the response so the auto transport can look at it. using var response = await SendHttpRequestAsync(message, cancellationToken).ConfigureAwait(false); + + // Per spec PR #2844 (HTTP backwards compatibility), a 400 Bad Request that carries a + // JSON-RPC error envelope means the peer is signalling something application-level about + // our request. Surface ANY JSON-RPC error on a 400 as McpProtocolException so the + // connect-time logic can react. For example, the three per-request metadata protocol error codes + // (-32022 UnsupportedProtocolVersion, -32021 MissingRequiredClientCapability, + // -32020 HeaderMismatch) lead to typed exceptions, while other codes (e.g. -32600 from + // initialize-handshake servers that don't understand the SEP-2575 _meta envelope) become generic + // McpProtocolException instances and trigger the initialize-handshake fallback path. + // Other status codes (401 auth, 403 forbidden, 404 session-not-found, 5xx server) continue + // to surface as HttpRequestException to preserve back-compat with transport-layer behaviors. + // The three per-request metadata protocol error codes are also surfaced for non-400 status codes + // for robustness. Servers occasionally emit them with 4xx codes other than 400. + if (!response.IsSuccessStatusCode && + await TryReadJsonRpcErrorAsync(response, cancellationToken).ConfigureAwait(false) is { } parsedError && + (response.StatusCode == HttpStatusCode.BadRequest || + IsPerRequestMetadataProtocolErrorCode((McpErrorCode)parsedError.Error.Code))) + { + throw McpSessionHandler.CreateRemoteProtocolExceptionFromError(parsedError); + } + await response.EnsureSuccessStatusCodeWithResponseBodyAsync(cancellationToken).ConfigureAwait(false); } + private static bool IsPerRequestMetadataProtocolErrorCode(McpErrorCode code) => + code is McpErrorCode.UnsupportedProtocolVersion + or McpErrorCode.MissingRequiredClientCapability + or McpErrorCode.HeaderMismatch; + + /// + /// Reads a JSON-RPC error envelope from an application/json response body, returning + /// when the response isn't JSON, is empty, or doesn't parse to a + /// . Shared with the auto-detecting transport so it can tell an MCP + /// server that rejected the request apart from a non-MCP endpoint without throwing. + /// + internal static async Task TryReadJsonRpcErrorAsync(HttpResponseMessage response, CancellationToken cancellationToken) + { + if (response.Content.Headers.ContentType?.MediaType != "application/json") + { + return null; + } + + string body; + try + { + body = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false); + } + catch + { + return null; + } + + if (string.IsNullOrEmpty(body)) + { + return null; + } + + try + { + return JsonSerializer.Deserialize(body, McpJsonUtilities.JsonContext.Default.JsonRpcMessage) as JsonRpcError; + } + catch + { + // Not a valid JSON-RPC error response — fall through to the standard HTTP exception path. + return null; + } + } + // This is used by the auto transport so it can fall back and try SSE given a non-200 response without catching an exception. internal async Task SendHttpRequestAsync(JsonRpcMessage message, CancellationToken cancellationToken) { @@ -78,6 +146,12 @@ internal async Task SendHttpRequestAsync(JsonRpcMessage mes LogTransportSendingMessageSensitive(message); + // Under the 2026-07-28 or later protocol revision (SEP-2575), every request carries its protocol version in + // _meta/io.modelcontextprotocol/protocolVersion (and the matching MCP-Protocol-Version HTTP + // header). Pick the value off the message so the first request (server/discover) can + // include the header even before we've recorded a negotiated version from an initialize reply. + var protocolVersionForRequest = ExtractProtocolVersionFromMeta(message) ?? _negotiatedProtocolVersion; + using var sendCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _connectionCts.Token); cancellationToken = sendCts.Token; @@ -89,7 +163,9 @@ internal async Task SendHttpRequestAsync(JsonRpcMessage mes }, }; - CopyAdditionalHeaders(httpRequestMessage.Headers, _options.AdditionalHeaders, SessionId, _negotiatedProtocolVersion); + CopyAdditionalHeaders(httpRequestMessage.Headers, _options.AdditionalHeaders, SessionId, protocolVersionForRequest); + + AddMcpRequestHeaders(httpRequestMessage.Headers, message); var response = await _httpClient.SendAsync(httpRequestMessage, message, cancellationToken).ConfigureAwait(false); @@ -112,7 +188,10 @@ internal async Task SendHttpRequestAsync(JsonRpcMessage mes if (response.Content.Headers.ContentType?.MediaType == "application/json") { var responseContent = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false); - rpcResponseOrError = await ProcessMessageAsync(responseContent, rpcRequest, cancellationToken).ConfigureAwait(false); + if (responseContent.Length > 0) + { + rpcResponseOrError = await ProcessMessageAsync(responseContent, rpcRequest, cancellationToken).ConfigureAwait(false); + } } else if (response.Content.Headers.ContentType?.MediaType == "text/event-stream") { @@ -143,7 +222,7 @@ internal async Task SendHttpRequestAsync(JsonRpcMessage mes if (rpcRequest.Method == RequestMethods.Initialize && rpcResponseOrError is JsonRpcResponse initResponse) { // We've successfully initialized! Copy session-id and protocol version, then start GET request if any. - if (response.Headers.TryGetValues("Mcp-Session-Id", out var sessionIdValues)) + if (response.Headers.TryGetValues(McpHttpHeaders.SessionId, out var sessionIdValues)) { SessionId = sessionIdValues.FirstOrDefault(); } @@ -151,12 +230,46 @@ internal async Task SendHttpRequestAsync(JsonRpcMessage mes var initializeResult = JsonSerializer.Deserialize(initResponse.Result, McpJsonUtilities.JsonContext.Default.InitializeResult); _negotiatedProtocolVersion = initializeResult?.ProtocolVersion; - _getReceiveTask ??= ReceiveUnsolicitedMessagesAsync(); + _streamableHttpAdopted = true; + StartUnsolicitedMessageStreamIfEnabled(); + } + else if (rpcRequest.Method == RequestMethods.ServerDiscover && rpcResponseOrError is JsonRpcResponse) + { + // Under the 2026-07-28 or later protocol revision (SEP-2575), server/discover replaces the initialize + // handshake. The transport caches the protocol version from the outgoing request's _meta + // so subsequent requests carry the matching MCP-Protocol-Version header without re-parsing. + _negotiatedProtocolVersion ??= ExtractProtocolVersionFromMeta(message); } return response; } + private void StartUnsolicitedMessageStreamIfEnabled() + { + if (_options.EnableStandaloneGetStream) + { + _getReceiveTask ??= ReceiveUnsolicitedMessagesAsync(); + } + } + + /// + /// Reads the protocol version from a request's _meta/io.modelcontextprotocol/protocolVersion field, + /// Introduced by the 2026-07-28 protocol revision (SEP-2575). Returns for messages that + /// don't have that field. + /// + private static string? ExtractProtocolVersionFromMeta(JsonRpcMessage message) + { + if (message is JsonRpcRequest { Params: System.Text.Json.Nodes.JsonObject paramsObj } && + paramsObj["_meta"] is System.Text.Json.Nodes.JsonObject metaObj && + metaObj[MetaKeys.ProtocolVersion] is System.Text.Json.Nodes.JsonValue versionValue && + versionValue.TryGetValue(out string? version)) + { + return version; + } + + return null; + } + public override async ValueTask DisposeAsync() { using var _ = await _disposeLock.LockAsync().ConfigureAwait(false); @@ -196,7 +309,7 @@ public override async ValueTask DisposeAsync() { // If we're auto-detecting the transport and failed to connect, leave the message Channel open for the SSE transport. // This class isn't directly exposed to public callers, so we don't have to worry about changing the _state in this case. - if (_options.TransportMode is not HttpTransportMode.AutoDetect || _getReceiveTask is not null) + if (_options.TransportMode is not HttpTransportMode.AutoDetect || _streamableHttpAdopted) { // _disconnectError is set when the server returns 404 indicating session expiry. // When null, this is a graceful client-initiated closure (no error). @@ -429,19 +542,19 @@ internal static void CopyAdditionalHeaders( string? protocolVersion, string? lastEventId = null) { - if (sessionId is not null) + if (sessionId is not null && McpProtocolVersions.SupportsHttpSessions(protocolVersion)) { - headers.Add("Mcp-Session-Id", sessionId); + headers.Add(McpHttpHeaders.SessionId, sessionId); } if (protocolVersion is not null) { - headers.Add("MCP-Protocol-Version", protocolVersion); + headers.Add(McpHttpHeaders.ProtocolVersion, protocolVersion); } if (lastEventId is not null) { - headers.Add("Last-Event-ID", lastEventId); + headers.Add(McpHttpHeaders.LastEventId, lastEventId); } if (additionalHeaders is null) @@ -458,6 +571,80 @@ internal static void CopyAdditionalHeaders( } } + /// + /// Adds standard MCP request headers (Mcp-Method, Mcp-Name) and custom parameter headers + /// (Mcp-Param-{Name}) to an HTTP request based on the JSON-RPC message being sent. + /// + internal static void AddMcpRequestHeaders(HttpRequestHeaders headers, JsonRpcMessage message) + { + string? method = message switch + { + JsonRpcRequest request => request.Method, + JsonRpcNotification notification => notification.Method, + _ => null, + }; + + if (method is null) + { + return; + } + + headers.Add(McpHttpHeaders.Method, method); + + // Add Mcp-Name header for methods that target a specific named resource +#pragma warning disable MCPEXP002 + string? name = message.Context?.RoutingName ?? message switch + { + JsonRpcRequest { Method: RequestMethods.ToolsCall or RequestMethods.PromptsGet } request + => GetParamsStringProperty(request.Params, "name"), + JsonRpcRequest { Method: RequestMethods.ResourcesRead } request + => GetParamsStringProperty(request.Params, "uri"), + _ => null, + }; +#pragma warning restore MCPEXP002 + + if (name is not null) + { + headers.Add(McpHttpHeaders.Name, name); + } + + // Add custom Mcp-Param-{Name} headers for tools/call requests with x-mcp-header annotations + if (method == RequestMethods.ToolsCall && + message is JsonRpcRequest toolsCallRequest && + toolsCallRequest.Context?.Items?.TryGetValue(McpHttpHeaders.ToolContextKey, out var toolObj) == true && + toolObj is Tool tool) + { + var arguments = GetParamsArguments(toolsCallRequest.Params); + McpHeaderExtractor.AddParameterHeaders(headers, tool, arguments); + } + } + + /// + /// Extracts a string property from the JSON-RPC params object. + /// + private static string? GetParamsStringProperty(JsonNode? paramsNode, string propertyName) + { + if (paramsNode is JsonObject obj && obj.TryGetPropertyValue(propertyName, out var value)) + { + return value?.GetValue(); + } + + return null; + } + + /// + /// Extracts the arguments property from a tools/call params object as a JsonElement. + /// + private static JsonElement? GetParamsArguments(JsonNode? paramsNode) + { + if (paramsNode is JsonObject obj && obj.TryGetPropertyValue("arguments", out var argsNode) && argsNode is not null) + { + return JsonSerializer.Deserialize(argsNode, McpJsonUtilities.JsonContext.Default.JsonElement); + } + + return null; + } + /// /// Tracks state across SSE stream connections. /// diff --git a/src/ModelContextProtocol.Core/CompatibilitySuppressions.xml b/src/ModelContextProtocol.Core/CompatibilitySuppressions.xml index 640351668..0497d618a 100644 --- a/src/ModelContextProtocol.Core/CompatibilitySuppressions.xml +++ b/src/ModelContextProtocol.Core/CompatibilitySuppressions.xml @@ -1,60 +1,3 @@  - - - CP0005 - M:ModelContextProtocol.Client.McpClient.get_Completion - lib/net10.0/ModelContextProtocol.Core.dll - lib/net10.0/ModelContextProtocol.Core.dll - true - - - CP0005 - P:ModelContextProtocol.Client.McpClient.Completion - lib/net10.0/ModelContextProtocol.Core.dll - lib/net10.0/ModelContextProtocol.Core.dll - true - - - CP0005 - M:ModelContextProtocol.Client.McpClient.get_Completion - lib/net8.0/ModelContextProtocol.Core.dll - lib/net8.0/ModelContextProtocol.Core.dll - true - - - CP0005 - P:ModelContextProtocol.Client.McpClient.Completion - lib/net8.0/ModelContextProtocol.Core.dll - lib/net8.0/ModelContextProtocol.Core.dll - true - - - CP0005 - M:ModelContextProtocol.Client.McpClient.get_Completion - lib/net9.0/ModelContextProtocol.Core.dll - lib/net9.0/ModelContextProtocol.Core.dll - true - - - CP0005 - P:ModelContextProtocol.Client.McpClient.Completion - lib/net9.0/ModelContextProtocol.Core.dll - lib/net9.0/ModelContextProtocol.Core.dll - true - - - CP0005 - M:ModelContextProtocol.Client.McpClient.get_Completion - lib/netstandard2.0/ModelContextProtocol.Core.dll - lib/netstandard2.0/ModelContextProtocol.Core.dll - true - - - CP0005 - P:ModelContextProtocol.Client.McpClient.Completion - lib/netstandard2.0/ModelContextProtocol.Core.dll - lib/netstandard2.0/ModelContextProtocol.Core.dll - true - - \ No newline at end of file + \ No newline at end of file diff --git a/src/ModelContextProtocol.Core/McpErrorCode.cs b/src/ModelContextProtocol.Core/McpErrorCode.cs index 33cd74a82..65c662a1a 100644 --- a/src/ModelContextProtocol.Core/McpErrorCode.cs +++ b/src/ModelContextProtocol.Core/McpErrorCode.cs @@ -5,15 +5,69 @@ namespace ModelContextProtocol; /// public enum McpErrorCode { + /// + /// Indicates that HTTP headers do not match the corresponding values in the request body, + /// or that required headers are missing or malformed. + /// + /// + /// + /// This error is returned when a Streamable HTTP request fails header validation. Validation failures include: + /// + /// + /// A required standard header (Mcp-Method, Mcp-Name) is missing. + /// A header value does not match the corresponding request body value. + /// A Base64-encoded header value cannot be decoded. + /// A header value contains invalid characters. + /// + /// + /// This error code is in the JSON-RPC implementation-defined server error range (-32000 to -32099). + /// + /// + HeaderMismatch = -32020, + /// /// Indicates that the requested resource could not be found. /// /// - /// This error should be used when a resource URI does not match any available resource on the server. - /// It allows clients to distinguish between missing resources and other types of errors. + /// + /// Legacy error code for unresolvable resource URIs. Newer protocol versions report this + /// condition with the standard JSON-RPC (-32602) instead. The SDK + /// selects between the two automatically based on the negotiated protocol version, so older + /// clients still see (-32002) and newer ones see + /// . + /// + /// + /// New user code throwing directly for unknown-resource conditions + /// should prefer ; the SDK will pass the value through unchanged. + /// /// ResourceNotFound = -32002, + /// + /// Indicates that a request requires a client capability that was not declared in the request's + /// _meta/io.modelcontextprotocol/clientCapabilities field. + /// + /// + /// + /// Introduced by the 2026-07-28 protocol revision (SEP-2575). The error data MUST include a + /// requiredCapabilities object describing the capabilities the server requires from the client + /// to process the request. For HTTP, the response status code is 400 Bad Request. + /// + /// + MissingRequiredClientCapability = -32021, + + /// + /// Indicates that the request's declared protocol version is not supported by the server. + /// + /// + /// + /// Introduced by the 2026-07-28 protocol revision (SEP-2575). The error data MUST include a + /// supported array of protocol version strings the server supports and the original + /// requested protocol version. For HTTP, the response status code is 400 Bad Request. + /// + /// + UnsupportedProtocolVersion = -32022, + /// /// Indicates that URL-mode elicitation is required to complete the requested operation. /// @@ -65,6 +119,7 @@ public enum McpErrorCode /// /// Tools: Unknown tool name or invalid protocol-level tool arguments. /// Prompts: Unknown prompt name or missing required protocol-level arguments. + /// Resources: Unknown or unresolvable resource URI. /// Pagination: Invalid or expired cursor values. /// Logging: Invalid log level. /// Tasks: Invalid or nonexistent task ID or invalid cursor. diff --git a/src/ModelContextProtocol.Core/McpJsonUtilities.cs b/src/ModelContextProtocol.Core/McpJsonUtilities.cs index abb6d29df..b193bb8de 100644 --- a/src/ModelContextProtocol.Core/McpJsonUtilities.cs +++ b/src/ModelContextProtocol.Core/McpJsonUtilities.cs @@ -1,4 +1,4 @@ -using Microsoft.Extensions.AI; +using Microsoft.Extensions.AI; using ModelContextProtocol.Authentication; using ModelContextProtocol.Protocol; using System.Diagnostics.CodeAnalysis; @@ -54,7 +54,13 @@ private static JsonSerializerOptions CreateDefaultOptions() return options; } - internal static JsonTypeInfo GetTypeInfo(this JsonSerializerOptions options) => + /// + /// Gets the resolved for from the specified options. + /// + /// The type whose serialization metadata should be resolved. + /// The serializer options providing the type-info resolver chain. + /// The resolved . + public static JsonTypeInfo GetTypeInfo(this JsonSerializerOptions options) => (JsonTypeInfo)options.GetTypeInfo(typeof(T)); internal static JsonElement DefaultMcpToolSchema { get; } = ParseJsonElement("""{"type":"object"}"""u8); @@ -84,6 +90,17 @@ internal static bool IsValidMcpToolSchema(JsonElement element) return false; // No type keyword found. } + // Per SEP-2106, a tool's outputSchema may be any valid JSON Schema document — not just + // schemas with type:"object". Validation is therefore reduced to a structural check + // matching JSON Schema 2020-12: a schema may be either a JSON object (the usual form + // with keywords like "type", "properties", etc.) or a boolean (`true` matches anything, + // `false` matches nothing). Stricter keyword-level validation is intentionally not + // performed. Pre-2026-07-28 clients still receive the legacy wrapped wire shape — that + // wiring lives in AIFunctionMcpServerTool.CreateStructuredResponse and McpServerImpl's + // listToolsHandler. + internal static bool IsValidToolOutputSchema(JsonElement element) => + element.ValueKind is JsonValueKind.Object or JsonValueKind.True or JsonValueKind.False; + // Keep in sync with CreateDefaultOptions above. [JsonSourceGenerationOptions(JsonSerializerDefaults.Web, DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull, @@ -96,6 +113,7 @@ internal static bool IsValidMcpToolSchema(JsonElement element) [JsonSerializable(typeof(JsonRpcNotification))] [JsonSerializable(typeof(JsonRpcResponse))] [JsonSerializable(typeof(JsonRpcError))] + [JsonSerializable(typeof(JsonRpcErrorDetail))] // MCP Notification Params [JsonSerializable(typeof(CancelledNotificationParams))] @@ -108,18 +126,22 @@ internal static bool IsValidMcpToolSchema(JsonElement element) [JsonSerializable(typeof(ResourceUpdatedNotificationParams))] [JsonSerializable(typeof(RootsListChangedNotificationParams))] [JsonSerializable(typeof(ToolListChangedNotificationParams))] - [JsonSerializable(typeof(McpTaskStatusNotificationParams))] // MCP Request Params / Results [JsonSerializable(typeof(CallToolRequestParams))] [JsonSerializable(typeof(CallToolResult))] - [JsonSerializable(typeof(CreateTaskResult))] [JsonSerializable(typeof(CompleteRequestParams))] [JsonSerializable(typeof(CompleteResult))] [JsonSerializable(typeof(CreateMessageRequestParams))] [JsonSerializable(typeof(CreateMessageResult))] + [JsonSerializable(typeof(DiscoverRequestParams))] + [JsonSerializable(typeof(DiscoverResult))] [JsonSerializable(typeof(ElicitRequestParams))] [JsonSerializable(typeof(ElicitResult))] + [JsonSerializable(typeof(MissingRequiredClientCapabilityErrorData))] + [JsonSerializable(typeof(SubscriptionsListenRequestParams))] + [JsonSerializable(typeof(SubscriptionsAcknowledgedNotificationParams))] + [JsonSerializable(typeof(UnsupportedProtocolVersionErrorData))] [JsonSerializable(typeof(UrlElicitationRequiredErrorData))] [JsonSerializable(typeof(EmptyResult))] [JsonSerializable(typeof(GetPromptRequestParams))] @@ -140,25 +162,17 @@ internal static bool IsValidMcpToolSchema(JsonElement element) [JsonSerializable(typeof(PingResult))] [JsonSerializable(typeof(ReadResourceRequestParams))] [JsonSerializable(typeof(ReadResourceResult))] + [JsonSerializable(typeof(CacheScope))] [JsonSerializable(typeof(SetLevelRequestParams))] [JsonSerializable(typeof(SubscribeRequestParams))] [JsonSerializable(typeof(UnsubscribeRequestParams))] - // MCP Task Request Params / Results - [JsonSerializable(typeof(McpTask))] - [JsonSerializable(typeof(McpTaskStatus))] - [JsonSerializable(typeof(McpTaskMetadata))] - [JsonSerializable(typeof(GetTaskRequestParams))] - [JsonSerializable(typeof(GetTaskResult))] - [JsonSerializable(typeof(GetTaskPayloadRequestParams))] - [JsonSerializable(typeof(ListTasksRequestParams))] - [JsonSerializable(typeof(ListTasksResult))] - [JsonSerializable(typeof(CancelMcpTaskRequestParams))] - [JsonSerializable(typeof(CancelMcpTaskResult))] - [JsonSerializable(typeof(McpTasksCapability))] - [JsonSerializable(typeof(RequestMcpTasksCapability))] - [JsonSerializable(typeof(ToolExecution))] - [JsonSerializable(typeof(ToolTaskSupport))] + // MCP MRTR (Multi Round-Trip Requests) + [JsonSerializable(typeof(InputRequiredResult))] + [JsonSerializable(typeof(InputRequest))] + [JsonSerializable(typeof(InputResponse))] + [JsonSerializable(typeof(IDictionary))] + [JsonSerializable(typeof(IDictionary))] // MCP Content [JsonSerializable(typeof(ContentBlock))] @@ -177,9 +191,14 @@ internal static bool IsValidMcpToolSchema(JsonElement element) [JsonSerializable(typeof(TextResourceContents))] // Other MCP Types + [JsonSerializable(typeof(IDictionary))] [JsonSerializable(typeof(IReadOnlyDictionary))] [JsonSerializable(typeof(ProgressToken))] [JsonSerializable(typeof(JsonElement))] + [JsonSerializable(typeof(Implementation))] + [JsonSerializable(typeof(ClientCapabilities))] + [JsonSerializable(typeof(ServerCapabilities))] + [JsonSerializable(typeof(LoggingLevel))] [JsonSerializable(typeof(ProtectedResourceMetadata))] [JsonSerializable(typeof(AuthorizationServerMetadata))] @@ -187,6 +206,12 @@ internal static bool IsValidMcpToolSchema(JsonElement element) [JsonSerializable(typeof(DynamicClientRegistrationRequest))] [JsonSerializable(typeof(DynamicClientRegistrationResponse))] + // For Enterprise Managed Authorization flow as specified at + // https://github.com/modelcontextprotocol/ext-auth/blob/main/specification/draft/enterprise-managed-authorization.mdx + [JsonSerializable(typeof(JagTokenExchangeResponse))] + [JsonSerializable(typeof(JwtBearerAccessTokenResponse))] + [JsonSerializable(typeof(OAuthErrorResponse))] + // Primitive types for use in consuming AIFunctions [JsonSerializable(typeof(string))] [JsonSerializable(typeof(byte))] diff --git a/src/ModelContextProtocol.Core/McpProtocolException.cs b/src/ModelContextProtocol.Core/McpProtocolException.cs index 3fbef91c0..7bcc4d0a8 100644 --- a/src/ModelContextProtocol.Core/McpProtocolException.cs +++ b/src/ModelContextProtocol.Core/McpProtocolException.cs @@ -76,7 +76,7 @@ public McpProtocolException(string message, Exception? innerException, McpErrorC /// -32700: Parse error - Invalid JSON received /// -32600: Invalid request - The JSON is not a valid Request object /// -32601: Method not found - The method does not exist or is not available - /// -32602: Invalid params - Malformed request or unknown primitive name (tool/prompt/resource) + /// -32602: Invalid params - Malformed request, unknown primitive name (tool/prompt/resource), or unresolvable resource URI /// -32603: Internal error - Internal JSON-RPC error /// /// diff --git a/src/ModelContextProtocol.Core/McpSession.cs b/src/ModelContextProtocol.Core/McpSession.cs index 4201f9833..1747a6303 100644 --- a/src/ModelContextProtocol.Core/McpSession.cs +++ b/src/ModelContextProtocol.Core/McpSession.cs @@ -45,6 +45,18 @@ public abstract partial class McpSession : IAsyncDisposable /// public abstract string? NegotiatedProtocolVersion { get; } + /// + /// Gets a value indicating whether the negotiated protocol version is 2026-07-28 or later: the + /// revision that removed the initialize handshake (SEP-2575) and Mcp-Session-Id (SEP-2567) + /// and enabled MRTR (SEP-2322). + /// + /// + /// Returns when no version has been negotiated yet. This is the shared + /// definition of "is this peer speaking the 2026-07-28 or later revision" used by both the client and server. + /// + internal bool IsJuly2026OrLaterProtocol() => + McpProtocolVersions.IsJuly2026OrLaterProtocolVersion(NegotiatedProtocolVersion); + /// /// Sends a JSON-RPC request to the connected session and waits for a response. /// @@ -68,7 +80,7 @@ public abstract partial class McpSession : IAsyncDisposable /// /// The to monitor for cancellation requests. The default is . /// A task that represents the asynchronous send operation. - /// The transport is not connected. + /// The transport is not connected, or is a . Use for requests. /// is . /// /// diff --git a/src/ModelContextProtocol.Core/McpSessionHandler.cs b/src/ModelContextProtocol.Core/McpSessionHandler.cs index 24543fd3e..61a1872f2 100644 --- a/src/ModelContextProtocol.Core/McpSessionHandler.cs +++ b/src/ModelContextProtocol.Core/McpSessionHandler.cs @@ -1,4 +1,4 @@ -using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging.Abstractions; using ModelContextProtocol.Client; using ModelContextProtocol.Protocol; @@ -28,20 +28,11 @@ internal sealed partial class McpSessionHandler : IAsyncDisposable private static readonly Histogram s_serverOperationDuration = Diagnostics.CreateDurationHistogram( "mcp.server.operation.duration", "MCP request or notification duration as observed on the receiver from the time it was received until the result or ack is sent."); - /// The latest version of the protocol supported by this implementation. - internal const string LatestProtocolVersion = "2025-11-25"; - /// - /// All protocol versions supported by this implementation. - /// Keep in sync with s_supportedProtocolVersions in StreamableHttpHandler. + /// All protocol versions supported by this implementation. The era-specific lists live on + /// so the shared source file is the single source of truth. /// - internal static readonly string[] SupportedProtocolVersions = - [ - "2024-11-05", - "2025-03-26", - "2025-06-18", - LatestProtocolVersion, - ]; + internal static readonly string[] SupportedProtocolVersions = McpProtocolVersions.SupportedProtocolVersions; /// /// Checks if the given protocol version supports priming events. @@ -54,7 +45,7 @@ internal sealed partial class McpSessionHandler : IAsyncDisposable /// internal static bool SupportsPrimingEvent(string? protocolVersion) { - const string MinResumabilityProtocolVersion = "2025-11-25"; + const string MinResumabilityProtocolVersion = McpProtocolVersions.November2025ProtocolVersion; if (protocolVersion is null) { @@ -64,6 +55,27 @@ internal static bool SupportsPrimingEvent(string? protocolVersion) return string.Compare(protocolVersion, MinResumabilityProtocolVersion, StringComparison.Ordinal) >= 0; } + /// + /// Checks whether the negotiated protocol version permits emitting non-object output + /// schemas and their structured content in their natural shape (per SEP-2106). + /// + /// The negotiated protocol version, or null if + /// negotiation has not completed. + /// true if the version is the 2026-07-28 revision or later, which is where + /// SEP-2106 widened outputSchema to any JSON Schema 2020-12 document; false otherwise. + /// A false return signals that the wire emission boundary must apply the + /// {"result": <value>} envelope expected by clients on protocol versions that pre-date + /// SEP-2106. + internal static bool SupportsNaturalOutputSchemas(string? protocolVersion) + { + if (protocolVersion is null) + { + return false; + } + + return string.Compare(protocolVersion, McpProtocolVersions.July2026ProtocolVersion, StringComparison.Ordinal) >= 0; + } + private readonly bool _isServer; private readonly string _transportKind; private readonly ITransport _transport; @@ -133,10 +145,24 @@ public McpSessionHandler( _outgoingMessageFilter = outgoingMessageFilter ?? (next => next); _logger = logger; - // Per the MCP spec, ping may be initiated by either party and must always be handled. + // ping was removed in the 2026-07-28 protocol revision (SEP-2575). On the 2026-07-28 or later version, + // return MethodNotFound; on an older version, the per-spec behavior is to always answer + // with PingResult. Liveness on those requests belongs to transport- and request-level + // timeouts, not a dedicated MCP RPC. _requestHandlers.Set( RequestMethods.Ping, - (request, _, cancellationToken) => new ValueTask(new PingResult()), + (request, jsonRpcRequest, cancellationToken) => + { + string? perRequestVersion = jsonRpcRequest?.Context?.ProtocolVersion ?? NegotiatedProtocolVersion; + if (McpProtocolVersions.RequiresPerRequestMetadata(perRequestVersion)) + { + throw new McpProtocolException( + $"Method '{RequestMethods.Ping}' is not available on protocol version '{perRequestVersion}'.", + McpErrorCode.MethodNotFound); + } + + return new ValueTask(new PingResult()); + }, McpJsonUtilities.JsonContext.Default.JsonNode, McpJsonUtilities.JsonContext.Default.PingResult); @@ -159,7 +185,7 @@ public McpSessionHandler( /// completes its channel with a , the wrapped /// is unwrapped. Otherwise, a default instance is returned. /// - internal Task CompletionTask => + internal Task CompletionTask => field ??= GetCompletionDetailsAsync(_transport.MessageReader.Completion); /// @@ -255,6 +281,18 @@ ex is OperationCanceledException && Message = urlException.Message, Data = urlException.CreateErrorDataNode(), }, + UnsupportedProtocolVersionException upvException => new() + { + Code = (int)upvException.ErrorCode, + Message = upvException.Message, + Data = upvException.CreateErrorDataNode(), + }, + MissingRequiredClientCapabilityException mrccException => new() + { + Code = (int)mrccException.ErrorCode, + Message = mrccException.Message, + Data = mrccException.CreateErrorDataNode(), + }, McpProtocolException mcpProtocolException => new() { Code = (int)mcpProtocolException.ErrorCode, @@ -363,6 +401,14 @@ private static async Task GetCompletionDetailsAsync(Tas private async Task HandleMessageAsync(JsonRpcMessage message, CancellationToken cancellationToken) { + // Project the 2026-07-28 protocol's per-request _meta fields onto the message context before any + // filters run so they (and downstream handlers) can read client info / capabilities / + // protocol version / log level without re-parsing. + if (_isServer && message is JsonRpcRequest incomingRequest) + { + PopulateContextFromMeta(incomingRequest); + } + Histogram durationMetric = _isServer ? s_serverOperationDuration : s_clientOperationDuration; string method = GetMethodName(message); @@ -498,6 +544,127 @@ await SendMessageAsync(new JsonRpcResponse return result; } + /// + /// Reads the 2026-07-28 protocol's per-request _meta fields off the request and projects them onto + /// so they're available without re-parsing throughout the pipeline. + /// + /// + /// Per SEP-2575 the keys are io.modelcontextprotocol/protocolVersion, + /// /clientInfo, /clientCapabilities, and (optional) /logLevel. Any field + /// that's already set on the context (e.g., + /// populated by the HTTP transport from the MCP-Protocol-Version header) is left alone + /// unless explicitly overwritten by a non-null value parsed here. + /// + internal static void PopulateContextFromMeta(JsonRpcRequest request) + { + if (request.Params is not JsonObject paramsObj) + { + return; + } + + if (paramsObj["_meta"] is not JsonObject metaObj) + { + return; + } + + var context = request.Context ??= new JsonRpcMessageContext(); + + if (metaObj[MetaKeys.ProtocolVersion] is JsonValue protocolVersion && + protocolVersion.TryGetValue(out string? protocolVersionValue)) + { + // If a transport-level header (e.g., the Streamable HTTP MCP-Protocol-Version header) already + // populated this, validate the body _meta matches per SEP-2575. A disagreement is reported with + // -32020 HeaderMismatch (the same code used for the Mcp-Method/Mcp-Name header-vs-body checks), + // which conformant 2026-07-28 clients recognize as a SEP-2575 signal and surface as-is rather + // than mistaking it for an initialize-handshake server and falling back to initialize. + if (context.ProtocolVersion is { } existing && !string.Equals(existing, protocolVersionValue, StringComparison.Ordinal)) + { + throw new McpProtocolException( + $"Header mismatch: the per-request _meta protocol version '{protocolVersionValue}' does not match the MCP-Protocol-Version header value '{existing}'.", + McpErrorCode.HeaderMismatch); + } + + context.ProtocolVersion = protocolVersionValue; + } + + if (metaObj[MetaKeys.ClientInfo] is JsonNode clientInfoNode) + { + context.ClientInfo = JsonSerializer.Deserialize(clientInfoNode, McpJsonUtilities.JsonContext.Default.Implementation); + } + + if (metaObj[MetaKeys.ClientCapabilities] is JsonNode clientCapabilitiesNode) + { + context.ClientCapabilities = JsonSerializer.Deserialize(clientCapabilitiesNode, McpJsonUtilities.JsonContext.Default.ClientCapabilities); + } + + if (metaObj[MetaKeys.LogLevel] is JsonNode logLevelNode) + { + context.LogLevel = JsonSerializer.Deserialize(logLevelNode, McpJsonUtilities.JsonContext.Default.LoggingLevel); + } + } + + /// + /// Injects the 2026-07-28 protocol's per-request _meta fields into an outgoing request. + /// Protocol version and client info overwrite any existing values; client capabilities are merged + /// so per-request capability opt-ins already present in the envelope are preserved. + /// + /// + /// Used by on a 2026-07-28 or later session to carry protocol version, client + /// info, and client capabilities on every outgoing request (replacing what the + /// initialize handshake previously negotiated once). + /// + internal static void InjectRequestMeta( + JsonRpcRequest request, + string protocolVersion, + Implementation clientInfo, + ClientCapabilities clientCapabilities, + LoggingLevel? logLevel = null) + { + var paramsObj = request.Params as JsonObject; + if (paramsObj is null) + { + paramsObj = new JsonObject(); + request.Params = paramsObj; + } + + if (paramsObj["_meta"] is not JsonObject metaObj) + { + metaObj = new JsonObject(); + paramsObj["_meta"] = metaObj; + } + + metaObj[MetaKeys.ProtocolVersion] = protocolVersion; + metaObj[MetaKeys.ClientInfo] = JsonSerializer.SerializeToNode(clientInfo, McpJsonUtilities.JsonContext.Default.Implementation); + + // Overlay the session-level standard capabilities onto whatever the request already carried + // in _meta.clientCapabilities. A caller higher up the pipeline (e.g. CallToolRawAsync via + // GetMetaWithTaskCapability) may have already written per-request capability opt-ins such as + // extensions/io.modelcontextprotocol/tasks. Blindly overwriting the node would drop those + // additions, so merge instead: set the standard capability fields from the session + // capabilities while preserving any extra keys (extensions) the request envelope already had. + var serializedCapabilities = (JsonObject)JsonSerializer.SerializeToNode(clientCapabilities, McpJsonUtilities.JsonContext.Default.ClientCapabilities)!; + if (metaObj[MetaKeys.ClientCapabilities] is JsonObject existingCapabilities) + { + foreach (var property in serializedCapabilities.ToArray()) + { + existingCapabilities[property.Key] = property.Value?.DeepClone(); + } + } + else + { + metaObj[MetaKeys.ClientCapabilities] = serializedCapabilities; + } + + if (logLevel is { } level) + { + metaObj[MetaKeys.LogLevel] = JsonSerializer.SerializeToNode(level, McpJsonUtilities.JsonContext.Default.LoggingLevel); + } + else + { + metaObj.Remove(MetaKeys.LogLevel); + } + } + private CancellationTokenRegistration RegisterCancellation(CancellationToken cancellationToken, JsonRpcRequest request) { if (!cancellationToken.CanBeCanceled) @@ -641,6 +808,13 @@ public async Task SendMessageAsync(JsonRpcMessage message, CancellationToken can { Throw.IfNull(message); + if (message is JsonRpcRequest request) + { + throw new InvalidOperationException( + $"Cannot send '{request.Method}' request via {nameof(SendMessageAsync)}. " + + $"Use {nameof(SendRequestAsync)} instead to get a correlated response."); + } + cancellationToken.ThrowIfCancellationRequested(); Histogram durationMetric = _isServer ? s_serverOperationDuration : s_clientOperationDuration; @@ -979,6 +1153,17 @@ private static TimeSpan GetElapsed(long startingTimestamp) => } private static McpProtocolException CreateRemoteProtocolException(JsonRpcError error) + => CreateRemoteProtocolExceptionFromError(error); + + /// + /// Creates a typed from a JSON-RPC error response. + /// + /// + /// Exposed internally so transports that surface an HTTP-level error containing a JSON-RPC error + /// body (e.g., a 400 with ) can convert + /// the error to the same typed exception that JSON-RPC-level error responses produce. + /// + internal static McpProtocolException CreateRemoteProtocolExceptionFromError(JsonRpcError error) { string formattedMessage = $"Request failed (remote): {error.Error.Message}"; var errorCode = (McpErrorCode)error.Error.Code; @@ -989,6 +1174,16 @@ private static McpProtocolException CreateRemoteProtocolException(JsonRpcError e { exception = urlException; } + else if (errorCode == McpErrorCode.UnsupportedProtocolVersion && + UnsupportedProtocolVersionException.TryCreateFromError(formattedMessage, error.Error, out var upvException)) + { + exception = upvException; + } + else if (errorCode == McpErrorCode.MissingRequiredClientCapability && + MissingRequiredClientCapabilityException.TryCreateFromError(formattedMessage, error.Error, out var mrccException)) + { + exception = mrccException; + } else { exception = new McpProtocolException(formattedMessage, errorCode); diff --git a/src/ModelContextProtocol.Core/McpTaskCancellationTokenProvider.cs b/src/ModelContextProtocol.Core/McpTaskCancellationTokenProvider.cs deleted file mode 100644 index 6ecfc4f4a..000000000 --- a/src/ModelContextProtocol.Core/McpTaskCancellationTokenProvider.cs +++ /dev/null @@ -1,127 +0,0 @@ -using System.Collections.Concurrent; - -namespace ModelContextProtocol; - -/// -/// Provides cancellation tokens for running MCP tasks, enabling TTL-based -/// automatic cancellation and explicit task cancellation. -/// -/// -/// -/// This class provides lifecycle management for instances -/// associated with running tasks. Each task gets its own CTS that can be: -/// -/// -/// Automatically cancelled when the task's TTL expires -/// Explicitly cancelled via the method -/// Cleaned up when the task completes via -/// -/// -/// Both McpClient and McpServer use this class to manage task cancellation -/// independently of request cancellation tokens. -/// -/// -internal sealed class McpTaskCancellationTokenProvider : IDisposable -{ - private readonly ConcurrentDictionary _runningTasks = new(); - private bool _disposed; - - /// - /// Registers a new task and returns a cancellation token for use during execution. - /// - /// The unique identifier of the task. - /// - /// Optional TTL duration. If specified, the returned token will be automatically - /// cancelled when the TTL expires. - /// - /// - /// A that will be cancelled when the TTL expires, - /// when is called, or when this provider is disposed. - /// - /// The provider has been disposed. - /// A task with the same ID is already registered. - public CancellationToken RequestToken(string taskId, TimeSpan? timeToLive) - { - if (_disposed) - { - throw new ObjectDisposedException(nameof(McpTaskCancellationTokenProvider)); - } - - Throw.IfNullOrWhiteSpace(taskId); - CancellationTokenSource cts = new(); - - if (timeToLive is { } ttl) - { - cts.CancelAfter(ttl); - } - - if (!_runningTasks.TryAdd(taskId, cts)) - { - cts.Dispose(); - throw new InvalidOperationException($"Task '{taskId}' is already registered."); - } - - return cts.Token; - } - - /// - /// Attempts to cancel a running task. - /// - /// The unique identifier of the task to cancel. - /// - /// This method signals cancellation but does not remove the task from tracking. - /// The task executor should call when it observes - /// the cancellation and finishes cleanup. - /// - public void Cancel(string taskId) - { - if (_runningTasks.TryGetValue(taskId, out var cts)) - { - cts.Cancel(); - } - } - - /// - /// Marks a task as complete and releases its associated resources. - /// - /// The unique identifier of the task that has completed. - /// - /// This method should be called from a finally block in the task execution - /// to ensure proper cleanup regardless of success, failure, or cancellation. - /// - public void Complete(string taskId) - { - if (_runningTasks.TryRemove(taskId, out var cts)) - { - cts.Dispose(); - } - } - - /// - /// Cancels all running tasks and releases all resources. - /// - public void Dispose() - { - if (_disposed) - { - return; - } - - _disposed = true; - - foreach (var kvp in _runningTasks) - { - try - { - kvp.Value.Cancel(); - kvp.Value.Dispose(); - } - catch - { - // Best effort cleanup - } - } - - _runningTasks.Clear(); - } -} diff --git a/src/ModelContextProtocol.Core/MissingRequiredClientCapabilityException.cs b/src/ModelContextProtocol.Core/MissingRequiredClientCapabilityException.cs new file mode 100644 index 000000000..9beaa7a51 --- /dev/null +++ b/src/ModelContextProtocol.Core/MissingRequiredClientCapabilityException.cs @@ -0,0 +1,67 @@ +using ModelContextProtocol.Protocol; +using System.Diagnostics.CodeAnalysis; +using System.Text.Json; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol; + +/// +/// Represents an exception used to signal that a request requires a client capability that was not declared +/// in the request's per-request _meta/io.modelcontextprotocol/clientCapabilities field. +/// +/// +/// Introduced by the 2026-07-28 protocol revision (SEP-2575). Servers throw this exception when a handler cannot +/// proceed because the client did not declare a required capability for the request. The exception is converted +/// to a JSON-RPC error response with code (-32021) +/// and a payload. +/// +public sealed class MissingRequiredClientCapabilityException : McpProtocolException +{ + /// + /// Initializes a new instance of the class. + /// + /// The capabilities the server requires for the request. + /// A human-readable description of the error. If , a default message is used. + public MissingRequiredClientCapabilityException(ClientCapabilities requiredCapabilities, string? message = null) + : base(message ?? "The request requires client capabilities that were not declared in _meta/clientCapabilities.", + McpErrorCode.MissingRequiredClientCapability) + { + Throw.IfNull(requiredCapabilities); + RequiredCapabilities = requiredCapabilities; + } + + /// Gets the client capabilities required for the request. + public ClientCapabilities RequiredCapabilities { get; } + + internal JsonNode CreateErrorDataNode() + { + var payload = new MissingRequiredClientCapabilityErrorData + { + RequiredCapabilities = RequiredCapabilities, + }; + + return JsonSerializer.SerializeToNode(payload, McpJsonUtilities.JsonContext.Default.MissingRequiredClientCapabilityErrorData)!; + } + + internal static bool TryCreateFromError( + string formattedMessage, + JsonRpcErrorDetail detail, + [NotNullWhen(true)] out MissingRequiredClientCapabilityException? exception) + { + exception = null; + + if (detail.Data is not JsonElement dataElement || dataElement.ValueKind is not JsonValueKind.Object) + { + return false; + } + + var payload = dataElement.Deserialize(McpJsonUtilities.JsonContext.Default.MissingRequiredClientCapabilityErrorData); + if (payload?.RequiredCapabilities is null) + { + return false; + } + + exception = new MissingRequiredClientCapabilityException(payload.RequiredCapabilities, formattedMessage); + return true; + } +} diff --git a/src/ModelContextProtocol.Core/ModelContextProtocol.Core.csproj b/src/ModelContextProtocol.Core/ModelContextProtocol.Core.csproj index f982d41cd..3fbef0377 100644 --- a/src/ModelContextProtocol.Core/ModelContextProtocol.Core.csproj +++ b/src/ModelContextProtocol.Core/ModelContextProtocol.Core.csproj @@ -7,8 +7,14 @@ ModelContextProtocol.Core Core .NET SDK for the Model Context Protocol (MCP) README.md - + $(MSBuildThisFileDirectory)CompatibilitySuppressions.xml + $(NoWarn);MCPEXP001 + + $(NoWarn);MCP9005 @@ -26,6 +32,8 @@ + + @@ -34,6 +42,7 @@ + diff --git a/src/ModelContextProtocol.Core/Protocol/CacheScope.cs b/src/ModelContextProtocol.Core/Protocol/CacheScope.cs new file mode 100644 index 000000000..d87cdd7f9 --- /dev/null +++ b/src/ModelContextProtocol.Core/Protocol/CacheScope.cs @@ -0,0 +1,44 @@ +using System.Text.Json.Serialization; + +namespace ModelContextProtocol.Protocol; + +/// +/// Indicates the intended scope of a cached response, analogous to the HTTP +/// Cache-Control: public and Cache-Control: private directives. +/// +/// +/// +/// This is used by to control who may cache a +/// response returned by tools/list, prompts/list, resources/list, +/// resources/templates/list, and resources/read. +/// +/// +/// When the field is absent from a response, clients should treat it as . +/// +/// +[JsonConverter(typeof(JsonStringEnumConverter))] +public enum CacheScope +{ + /// + /// The response does not contain user-specific data. Any client, shared gateway, or caching + /// proxy may store and serve the cached response to any user. + /// + /// + /// This is appropriate for lists of tools, prompts, and resource templates that are identical + /// for all users. + /// + [JsonStringEnumMemberName("public")] + Public, + + /// + /// The response contains user-specific data. Only the requesting user's client may cache it. + /// Shared caches (for example, multi-tenant gateways) must not serve the cached response to a + /// different user. + /// + /// + /// This is appropriate for resources/read results that depend on the authenticated user, + /// or for filtered list results that vary per user. + /// + [JsonStringEnumMemberName("private")] + Private +} diff --git a/src/ModelContextProtocol.Core/Protocol/CacheScopeConverter.cs b/src/ModelContextProtocol.Core/Protocol/CacheScopeConverter.cs new file mode 100644 index 000000000..ef61df263 --- /dev/null +++ b/src/ModelContextProtocol.Core/Protocol/CacheScopeConverter.cs @@ -0,0 +1,70 @@ +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace ModelContextProtocol.Protocol; + +/// +/// Serializes caching-scope hints, tolerating unknown or future values on read. +/// +/// +/// +/// SEP-2549 introduces cacheScope as a forward-looking caching hint. If a server sends an +/// unrecognized scope string (for example, a value added in a later revision of the specification) or a +/// non-string token, this converter maps it to rather than throwing. This prevents +/// a single unexpected hint from breaking deserialization of the entire result (for example, the whole +/// tool list). A result is the same as an absent field, which clients treat as +/// . +/// +/// +/// This converter is applied per-property on the cacheable result types. The +/// enum itself retains a standard string converter for any standalone serialization. +/// +/// +internal sealed class CacheScopeConverter : JsonConverter +{ + public override CacheScope? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + if (reader.TokenType is JsonTokenType.String) + { + string? value = reader.GetString(); + + // Match case-insensitively so a non-conforming casing of "private" (a security-relevant hint) + // is honored rather than falling through to null, which clients would treat as "public" and + // could cache user-specific data in a shared cache. Genuinely unknown values still map to null. + if (string.Equals(value, "public", StringComparison.OrdinalIgnoreCase)) + { + return CacheScope.Public; + } + + if (string.Equals(value, "private", StringComparison.OrdinalIgnoreCase)) + { + return CacheScope.Private; + } + + return null; + } + + // Any non-string token (number, bool, object, array) is an unrecognized hint. Consume the whole + // value, including the contents of an object or array, so the reader is left correctly positioned + // before mapping to null. Skipping is required for container tokens: returning without consuming + // them would leave the reader mispositioned and break deserialization of the enclosing result. + reader.Skip(); + return null; + } + + public override void Write(Utf8JsonWriter writer, CacheScope? value, JsonSerializerOptions options) + { + if (value is null) + { + writer.WriteNullValue(); + return; + } + + writer.WriteStringValue(value switch + { + CacheScope.Public => "public", + CacheScope.Private => "private", + _ => throw new JsonException($"Unsupported {nameof(CacheScope)} value: {value}."), + }); + } +} diff --git a/src/ModelContextProtocol.Core/Protocol/CallToolRequestParams.cs b/src/ModelContextProtocol.Core/Protocol/CallToolRequestParams.cs index 8267cd06f..d311c6b4f 100644 --- a/src/ModelContextProtocol.Core/Protocol/CallToolRequestParams.cs +++ b/src/ModelContextProtocol.Core/Protocol/CallToolRequestParams.cs @@ -26,24 +26,4 @@ public sealed class CallToolRequestParams : RequestParams /// [JsonPropertyName("arguments")] public IDictionary? Arguments { get; set; } - - /// - /// Gets or sets optional task metadata to augment this request with task execution. - /// - /// - /// When present, indicates that the requestor wants this operation executed as a task. - /// The receiver must support task augmentation for this specific request type. - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - [JsonIgnore] - public McpTaskMetadata? Task - { - get => TaskCore; - set => TaskCore = value; - } - - // See ExperimentalInternalPropertyTests.cs before modifying this property. - [JsonInclude] - [JsonPropertyName("task")] - internal McpTaskMetadata? TaskCore { get; set; } } diff --git a/src/ModelContextProtocol.Core/Protocol/CallToolResult.cs b/src/ModelContextProtocol.Core/Protocol/CallToolResult.cs index 35dba5b6e..b2fdb3d05 100644 --- a/src/ModelContextProtocol.Core/Protocol/CallToolResult.cs +++ b/src/ModelContextProtocol.Core/Protocol/CallToolResult.cs @@ -64,25 +64,4 @@ public sealed class CallToolResult : Result /// [JsonPropertyName("isError")] public bool? IsError { get; set; } - - /// - /// Gets or sets the task data for the newly created task. - /// - /// - /// This property is populated only for task-augmented tool calls. When present, the other properties - /// (, , ) may not be populated. - /// The actual tool result can be retrieved later via tasks/result. - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - [JsonIgnore] - public McpTask? Task - { - get => TaskCore; - set => TaskCore = value; - } - - // See ExperimentalInternalPropertyTests.cs before modifying this property. - [JsonInclude] - [JsonPropertyName("task")] - internal McpTask? TaskCore { get; set; } } diff --git a/src/ModelContextProtocol.Core/Protocol/CancelMcpTaskRequestParams.cs b/src/ModelContextProtocol.Core/Protocol/CancelMcpTaskRequestParams.cs deleted file mode 100644 index c4fb540b2..000000000 --- a/src/ModelContextProtocol.Core/Protocol/CancelMcpTaskRequestParams.cs +++ /dev/null @@ -1,84 +0,0 @@ -using System.Diagnostics.CodeAnalysis; -using System.Text.Json.Serialization; - -namespace ModelContextProtocol.Protocol; - -/// -/// Represents the parameters for a tasks/cancel request to explicitly cancel a task. -/// -/// -/// -/// Receivers must reject cancellation requests for tasks already in a terminal status -/// (, , or -/// ) with error code -32602 (Invalid params). -/// -/// -/// Upon receiving a valid cancellation request, receivers should attempt to stop the task -/// execution and must transition the task to status -/// before sending the response. -/// -/// -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -public sealed class CancelMcpTaskRequestParams : RequestParams -{ - /// - /// Gets or sets the unique identifier of the task to cancel. - /// - [JsonPropertyName("taskId")] - public required string TaskId { get; set; } -} - -/// -/// Represents the result of a tasks/cancel request. -/// -/// -/// The result contains the updated task state after cancellation. The task will be in -/// status if the cancellation was successful. -/// -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -public sealed class CancelMcpTaskResult : Result -{ - /// - /// Gets or sets the task ID. - /// - [JsonPropertyName("taskId")] - public required string TaskId { get; set; } - - /// - /// Gets or sets the current status of the task (should be ). - /// - [JsonPropertyName("status")] - public required McpTaskStatus Status { get; set; } - - /// - /// Gets or sets an optional message describing the cancellation. - /// - [JsonPropertyName("statusMessage")] - public string? StatusMessage { get; set; } - - /// - /// Gets or sets the ISO 8601 timestamp when the task was created. - /// - [JsonPropertyName("createdAt")] - public required DateTimeOffset CreatedAt { get; set; } - - /// - /// Gets or sets the ISO 8601 timestamp when the task status was last updated. - /// - [JsonPropertyName("lastUpdatedAt")] - public required DateTimeOffset LastUpdatedAt { get; set; } - - /// - /// Gets or sets the time to live (retention duration) from creation before the task may be deleted. - /// - [JsonPropertyName("ttl")] - [JsonConverter(typeof(TimeSpanMillisecondsConverter))] - public TimeSpan? TimeToLive { get; set; } - - /// - /// Gets or sets the suggested time between status checks. - /// - [JsonPropertyName("pollInterval")] - [JsonConverter(typeof(TimeSpanMillisecondsConverter))] - public TimeSpan? PollInterval { get; set; } -} diff --git a/src/ModelContextProtocol.Core/Protocol/ClientCapabilities.cs b/src/ModelContextProtocol.Core/Protocol/ClientCapabilities.cs index 77b2bef9f..2828602fc 100644 --- a/src/ModelContextProtocol.Core/Protocol/ClientCapabilities.cs +++ b/src/ModelContextProtocol.Core/Protocol/ClientCapabilities.cs @@ -1,5 +1,3 @@ -using System.ComponentModel; -using System.Diagnostics.CodeAnalysis; using System.Text.Json.Serialization; using ModelContextProtocol.Client; using ModelContextProtocol.Server; @@ -52,6 +50,7 @@ public sealed class ClientCapabilities /// /// [JsonPropertyName("roots")] + [Obsolete(Obsoletions.DeprecatedRoots_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public RootsCapability? Roots { get; set; } /// @@ -59,6 +58,7 @@ public sealed class ClientCapabilities /// supports issuing requests to an LLM on behalf of the server. /// [JsonPropertyName("sampling")] + [Obsolete(Obsoletions.DeprecatedSampling_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public SamplingCapability? Sampling { get; set; } /// @@ -68,32 +68,6 @@ public sealed class ClientCapabilities [JsonPropertyName("elicitation")] public ElicitationCapability? Elicitation { get; set; } - /// - /// Gets or sets the client's tasks capability for supporting task-augmented requests. - /// - /// - /// - /// The tasks capability enables servers to augment their requests with tasks for long-running - /// operations. When present, servers can request that certain operations (like sampling or - /// elicitation) execute asynchronously, with the ability to poll for status and retrieve results later. - /// - /// - /// See for details on configuring which operations support tasks. - /// - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - [JsonIgnore] - public McpTasksCapability? Tasks - { - get => TasksCore; - set => TasksCore = value; - } - - // See ExperimentalInternalPropertyTests.cs before modifying this property. - [JsonInclude] - [JsonPropertyName("tasks")] - internal McpTasksCapability? TasksCore { get; set; } - /// /// Gets or sets optional MCP extensions that the client supports. /// @@ -108,16 +82,6 @@ public McpTasksCapability? Tasks /// interoperability. Clients advertise extension support via this field during the initialization handshake. /// /// - [Experimental(Experimentals.Extensions_DiagnosticId, UrlFormat = Experimentals.Extensions_Url)] - [JsonIgnore] - public IDictionary? Extensions - { - get => ExtensionsCore; - set => ExtensionsCore = value; - } - - // See ExperimentalInternalPropertyTests.cs before modifying this property. - [JsonInclude] [JsonPropertyName("extensions")] - internal IDictionary? ExtensionsCore { get; set; } + public IDictionary? Extensions { get; set; } } diff --git a/src/ModelContextProtocol.Core/Protocol/ContentBlock.cs b/src/ModelContextProtocol.Core/Protocol/ContentBlock.cs index 83cc9d16b..d0b1b80ec 100644 --- a/src/ModelContextProtocol.Core/Protocol/ContentBlock.cs +++ b/src/ModelContextProtocol.Core/Protocol/ContentBlock.cs @@ -760,6 +760,9 @@ public sealed class ResourceLinkBlock : ContentBlock /// Represents a request from the assistant to call a tool. [DebuggerDisplay("Name = {Name}, Id = {Id}")] +// Sampling support type: this content block only appears inside sampling messages (an assistant tool call), +// so it is deprecated together with sampling per SEP-2577. +[Obsolete(Obsoletions.DeprecatedSampling_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public sealed class ToolUseContentBlock : ContentBlock { /// @@ -789,6 +792,9 @@ public sealed class ToolUseContentBlock : ContentBlock /// Represents the result of a tool use, provided by the user back to the assistant. [DebuggerDisplay("{DebuggerDisplay,nq}")] +// Sampling support type: this content block only appears inside sampling messages (a tool result returned to +// the assistant), so it is deprecated together with sampling per SEP-2577. +[Obsolete(Obsoletions.DeprecatedSampling_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public sealed class ToolResultContentBlock : ContentBlock { /// diff --git a/src/ModelContextProtocol.Core/Protocol/ContextInclusion.cs b/src/ModelContextProtocol.Core/Protocol/ContextInclusion.cs index fbe6be56f..5979fa868 100644 --- a/src/ModelContextProtocol.Core/Protocol/ContextInclusion.cs +++ b/src/ModelContextProtocol.Core/Protocol/ContextInclusion.cs @@ -16,6 +16,9 @@ namespace ModelContextProtocol.Protocol; /// /// [JsonConverter(typeof(JsonStringEnumConverter))] +// Sampling support type: only used to select what context to include on sampling (createMessage) requests, +// so it is deprecated together with sampling per SEP-2577. +[Obsolete(Obsoletions.DeprecatedSampling_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public enum ContextInclusion { /// diff --git a/src/ModelContextProtocol.Core/Protocol/CreateMessageRequestParams.cs b/src/ModelContextProtocol.Core/Protocol/CreateMessageRequestParams.cs index ef5e57d2c..7a4f32984 100644 --- a/src/ModelContextProtocol.Core/Protocol/CreateMessageRequestParams.cs +++ b/src/ModelContextProtocol.Core/Protocol/CreateMessageRequestParams.cs @@ -11,6 +11,9 @@ namespace ModelContextProtocol.Protocol; /// /// See the schema for details. /// +// Sampling support type: "createMessage" is the sampling request, so this is deprecated together with +// sampling per SEP-2577. +[Obsolete(Obsoletions.DeprecatedSampling_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public sealed class CreateMessageRequestParams : RequestParams { /// @@ -153,24 +156,4 @@ public sealed class CreateMessageRequestParams : RequestParams /// [JsonPropertyName("toolChoice")] public ToolChoice? ToolChoice { get; set; } - - /// - /// Gets or sets optional task metadata to augment this request with task execution. - /// - /// - /// When present, indicates that the requestor wants this operation executed as a task. - /// The receiver must support task augmentation for this specific request type. - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - [JsonIgnore] - public McpTaskMetadata? Task - { - get => TaskCore; - set => TaskCore = value; - } - - // See ExperimentalInternalPropertyTests.cs before modifying this property. - [JsonInclude] - [JsonPropertyName("task")] - internal McpTaskMetadata? TaskCore { get; set; } } diff --git a/src/ModelContextProtocol.Core/Protocol/CreateMessageResult.cs b/src/ModelContextProtocol.Core/Protocol/CreateMessageResult.cs index 94472421b..7568b4552 100644 --- a/src/ModelContextProtocol.Core/Protocol/CreateMessageResult.cs +++ b/src/ModelContextProtocol.Core/Protocol/CreateMessageResult.cs @@ -8,6 +8,9 @@ namespace ModelContextProtocol.Protocol; /// /// See the schema for details. /// +// Sampling support type: "createMessage" is the sampling request, so this result is deprecated together +// with sampling per SEP-2577. +[Obsolete(Obsoletions.DeprecatedSampling_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public sealed class CreateMessageResult : Result { /// diff --git a/src/ModelContextProtocol.Core/Protocol/CreateTaskResult.cs b/src/ModelContextProtocol.Core/Protocol/CreateTaskResult.cs deleted file mode 100644 index 166d05e49..000000000 --- a/src/ModelContextProtocol.Core/Protocol/CreateTaskResult.cs +++ /dev/null @@ -1,28 +0,0 @@ -using System.Diagnostics.CodeAnalysis; -using System.Text.Json.Serialization; - -namespace ModelContextProtocol.Protocol; - -/// -/// Represents the response to a task-augmented request. -/// -/// -/// -/// When a client sends a request with a task parameter, the server immediately returns -/// a containing the created task information instead of the -/// normal result type. The actual result can be retrieved later via tasks/result. -/// -/// -/// This type is returned for any task-augmented request including tools/call, -/// sampling/createMessage, and elicitation/create. -/// -/// -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -public sealed class CreateTaskResult : Result -{ - /// - /// Gets or sets the task data for the newly created task. - /// - [JsonPropertyName("task")] - public McpTask Task { get; set; } = null!; -} diff --git a/src/ModelContextProtocol.Core/Protocol/DiscoverRequestParams.cs b/src/ModelContextProtocol.Core/Protocol/DiscoverRequestParams.cs new file mode 100644 index 000000000..198fb4311 --- /dev/null +++ b/src/ModelContextProtocol.Core/Protocol/DiscoverRequestParams.cs @@ -0,0 +1,16 @@ +namespace ModelContextProtocol.Protocol; + +/// +/// Represents the parameters used with a request. +/// +/// +/// +/// The discover RPC takes no payload of its own. Per-request metadata +/// (protocol version, client info, client capabilities) flows through the +/// inherited property under the +/// io.modelcontextprotocol/* keys defined by the 2026-07-28 protocol revision (SEP-2575). +/// +/// +public sealed class DiscoverRequestParams : RequestParams +{ +} diff --git a/src/ModelContextProtocol.Core/Protocol/DiscoverResult.cs b/src/ModelContextProtocol.Core/Protocol/DiscoverResult.cs new file mode 100644 index 000000000..b178a3a98 --- /dev/null +++ b/src/ModelContextProtocol.Core/Protocol/DiscoverResult.cs @@ -0,0 +1,66 @@ +using System.Text.Json.Serialization; + +namespace ModelContextProtocol.Protocol; + +/// +/// Represents the result returned from a request. +/// +/// +/// +/// Introduced by the 2026-07-28 protocol revision (SEP-2575) as the canonical way for a client +/// to learn what a server supports without performing the initialize handshake. +/// +/// +public sealed class DiscoverResult : Result, ICacheableResult +{ + /// + /// Gets or sets the list of MCP protocol version strings the server supports for subsequent + /// per-request metadata requests. + /// + /// + /// The client should choose a version from this list for subsequent requests that carry the + /// 2026-07-28-style per-request _meta envelope. Versions that require the + /// initialize handshake are negotiated through initialize instead. + /// + [JsonPropertyName("supportedVersions")] + public required IList SupportedVersions { get; set; } + + /// + /// Gets or sets the capabilities of the server. + /// + [JsonPropertyName("capabilities")] + public required ServerCapabilities Capabilities { get; set; } + + /// + /// Gets or sets optional instructions describing how to use the server and its features. + /// + /// + /// This can be used by clients to improve an LLM's understanding of the server, + /// for example by including it in a system prompt. + /// + [JsonPropertyName("instructions")] + public string? Instructions { get; set; } + + /// + /// + /// Spec PR #2855 makes ttlMs a required field on . The + /// server emits a safe default (, i.e. immediately stale) for the + /// 2026-07-28 and later protocol revisions when the application has not set an explicit value, + /// preserving today's + /// "do not cache" behavior while satisfying the wire requirement. + /// + [JsonPropertyName("ttlMs")] + [JsonConverter(typeof(TimeSpanMillisecondsConverter))] + public TimeSpan? TimeToLive { get; set; } + + /// + /// + /// Spec PR #2855 makes cacheScope a required field on . The + /// server emits a safe default () for the 2026-07-28 and + /// later protocol revisions + /// when the application has not set an explicit value. + /// + [JsonPropertyName("cacheScope")] + [JsonConverter(typeof(CacheScopeConverter))] + public CacheScope? CacheScope { get; set; } +} diff --git a/src/ModelContextProtocol.Core/Protocol/ElicitRequestParams.cs b/src/ModelContextProtocol.Core/Protocol/ElicitRequestParams.cs index 39a5bd358..9dc1ac903 100644 --- a/src/ModelContextProtocol.Core/Protocol/ElicitRequestParams.cs +++ b/src/ModelContextProtocol.Core/Protocol/ElicitRequestParams.cs @@ -92,26 +92,6 @@ public string Mode [JsonPropertyName("requestedSchema")] public RequestSchema? RequestedSchema { get; set; } - /// - /// Gets or sets optional task metadata to augment this request with task execution. - /// - /// - /// When present, indicates that the requestor wants this operation executed as a task. - /// The receiver must support task augmentation for this specific request type. - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - [JsonIgnore] - public McpTaskMetadata? Task - { - get => TaskCore; - set => TaskCore = value; - } - - // See ExperimentalInternalPropertyTests.cs before modifying this property. - [JsonInclude] - [JsonPropertyName("task")] - internal McpTaskMetadata? TaskCore { get; set; } - /// Represents a request schema used in a form mode elicitation request. public sealed class RequestSchema { diff --git a/src/ModelContextProtocol.Core/Protocol/EmptyResult.cs b/src/ModelContextProtocol.Core/Protocol/EmptyResult.cs index cf26cc3d5..6bf9d633d 100644 --- a/src/ModelContextProtocol.Core/Protocol/EmptyResult.cs +++ b/src/ModelContextProtocol.Core/Protocol/EmptyResult.cs @@ -9,5 +9,5 @@ namespace ModelContextProtocol.Protocol; public sealed class EmptyResult : Result { [JsonIgnore] - internal static EmptyResult Instance { get; } = new(); + internal static EmptyResult Instance { get; } = new() { ResultType = "complete" }; } \ No newline at end of file diff --git a/src/ModelContextProtocol.Core/Protocol/GetTaskPayloadRequestParams.cs b/src/ModelContextProtocol.Core/Protocol/GetTaskPayloadRequestParams.cs deleted file mode 100644 index d64a8b1f9..000000000 --- a/src/ModelContextProtocol.Core/Protocol/GetTaskPayloadRequestParams.cs +++ /dev/null @@ -1,27 +0,0 @@ -using System.Diagnostics.CodeAnalysis; -using System.Text.Json.Serialization; - -namespace ModelContextProtocol.Protocol; - -/// -/// Represents the parameters for a tasks/result request to retrieve the result of a completed task. -/// -/// -/// -/// This request blocks until the task reaches a terminal status (, -/// , or ). -/// -/// -/// The result structure matches the original request type (e.g., for tools/call). -/// This is distinct from the initial response, which contains only task data. -/// -/// -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -public sealed class GetTaskPayloadRequestParams : RequestParams -{ - /// - /// Gets or sets the unique identifier of the task whose result to retrieve. - /// - [JsonPropertyName("taskId")] - public required string TaskId { get; set; } -} diff --git a/src/ModelContextProtocol.Core/Protocol/GetTaskRequestParams.cs b/src/ModelContextProtocol.Core/Protocol/GetTaskRequestParams.cs deleted file mode 100644 index a8aaaea93..000000000 --- a/src/ModelContextProtocol.Core/Protocol/GetTaskRequestParams.cs +++ /dev/null @@ -1,77 +0,0 @@ -using System.Diagnostics.CodeAnalysis; -using System.Text.Json.Serialization; - -namespace ModelContextProtocol.Protocol; - -/// -/// Represents the parameters for a tasks/get request to retrieve task status. -/// -/// -/// Requestors poll for task completion by sending tasks/get requests. They should -/// respect the provided in responses when determining -/// polling frequency. -/// -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -public sealed class GetTaskRequestParams : RequestParams -{ - /// - /// Gets or sets the unique identifier of the task to retrieve. - /// - [JsonPropertyName("taskId")] - public required string TaskId { get; set; } -} - -/// -/// Represents the result of a tasks/get request. -/// -/// -/// The result contains the current state of the task, including its status, timestamps, -/// and any status message. -/// -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -public sealed class GetTaskResult : Result -{ - /// - /// Gets or sets the task ID. - /// - [JsonPropertyName("taskId")] - public required string TaskId { get; set; } - - /// - /// Gets or sets the current status of the task. - /// - [JsonPropertyName("status")] - public required McpTaskStatus Status { get; set; } - - /// - /// Gets or sets an optional human-readable message describing the current state. - /// - [JsonPropertyName("statusMessage")] - public string? StatusMessage { get; set; } - - /// - /// Gets or sets the ISO 8601 timestamp when the task was created. - /// - [JsonPropertyName("createdAt")] - public required DateTimeOffset CreatedAt { get; set; } - - /// - /// Gets or sets the ISO 8601 timestamp when the task status was last updated. - /// - [JsonPropertyName("lastUpdatedAt")] - public required DateTimeOffset LastUpdatedAt { get; set; } - - /// - /// Gets or sets the time to live (retention duration) from creation before the task may be deleted. - /// - [JsonPropertyName("ttl")] - [JsonConverter(typeof(TimeSpanMillisecondsConverter))] - public TimeSpan? TimeToLive { get; set; } - - /// - /// Gets or sets the suggested time between status checks. - /// - [JsonPropertyName("pollInterval")] - [JsonConverter(typeof(TimeSpanMillisecondsConverter))] - public TimeSpan? PollInterval { get; set; } -} diff --git a/src/ModelContextProtocol.Core/Protocol/ICacheableResult.cs b/src/ModelContextProtocol.Core/Protocol/ICacheableResult.cs new file mode 100644 index 000000000..93797df05 --- /dev/null +++ b/src/ModelContextProtocol.Core/Protocol/ICacheableResult.cs @@ -0,0 +1,59 @@ +namespace ModelContextProtocol.Protocol; + +/// +/// Represents a result that carries time-to-live (TTL) caching hints, allowing clients to cache +/// the response for a period of time before re-fetching. +/// +/// +/// +/// This interface corresponds to the CacheableResult type in the Model Context Protocol +/// schema and is implemented by the results of server/discover, tools/list, +/// prompts/list, resources/list, resources/templates/list, and +/// resources/read. +/// +/// +/// The TTL is a freshness hint, not a guarantee. It supplements rather than replaces the existing +/// list_changed and resources/updated notification mechanisms; both can coexist. A +/// relevant notification invalidates a cached response regardless of any remaining TTL. +/// +/// +public interface ICacheableResult +{ + /// + /// Gets or sets a hint indicating how long the client may cache this response before re-fetching. + /// + /// + /// + /// The semantics are analogous to the HTTP Cache-Control: max-age directive. The value is + /// serialized as an integer number of milliseconds under the ttlMs JSON property. + /// + /// + /// A value of indicates the response should be considered immediately + /// stale; a positive value indicates the client should consider the response fresh for that + /// duration from the time it was received. + /// + /// + /// When this property is (the field was absent from the response), clients + /// should assume a default of (immediately stale) and rely on their + /// own caching heuristics or notifications. The SDK preserves whatever value the server sent and + /// does not coerce it; a client that receives a negative value should treat it as immediately stale. + /// + /// + TimeSpan? TimeToLive { get; set; } + + /// + /// Gets or sets the intended scope of the cached response. + /// + /// + /// + /// When this property is (the field was absent from the response), clients + /// should treat the response as . + /// + /// + /// An unrecognized or future scope value sent by a server (or a non-string value) is tolerated and + /// surfaced as rather than causing deserialization of the whole result to + /// fail, so a single unexpected hint never prevents a client from reading the result. + /// + /// + CacheScope? CacheScope { get; set; } +} diff --git a/src/ModelContextProtocol.Core/Protocol/InitializeRequestParams.cs b/src/ModelContextProtocol.Core/Protocol/InitializeRequestParams.cs index 468754e96..63b17cdfe 100644 --- a/src/ModelContextProtocol.Core/Protocol/InitializeRequestParams.cs +++ b/src/ModelContextProtocol.Core/Protocol/InitializeRequestParams.cs @@ -22,16 +22,17 @@ namespace ModelContextProtocol.Protocol; public sealed class InitializeRequestParams : RequestParams { /// - /// Gets or sets the version of the Model Context Protocol that the client wants to use. + /// Gets or sets the initialize-handshake Model Context Protocol version that the client wants to use. /// /// /// /// Protocol version is specified using a date-based versioning scheme in the format "YYYY-MM-DD". - /// The client and server must agree on a protocol version to communicate successfully. + /// The client and server must agree on an initialize-capable protocol version to communicate successfully. /// /// - /// During initialization, the server will check if it supports this requested version. If there's a - /// mismatch, the server will reject the connection with a version mismatch error. + /// During initialization, the server will check if it supports this requested version. Protocol + /// revisions starting with 2026-07-28 do not use initialize; clients select them with + /// server/discover and per-request metadata instead. /// /// /// See the protocol specification for version details. diff --git a/src/ModelContextProtocol.Core/Protocol/InitializeResult.cs b/src/ModelContextProtocol.Core/Protocol/InitializeResult.cs index e79113687..4c0f014f0 100644 --- a/src/ModelContextProtocol.Core/Protocol/InitializeResult.cs +++ b/src/ModelContextProtocol.Core/Protocol/InitializeResult.cs @@ -22,11 +22,11 @@ namespace ModelContextProtocol.Protocol; public sealed class InitializeResult : Result { /// - /// Gets or sets the version of the Model Context Protocol that the server will use for this session. + /// Gets or sets the initialize-handshake Model Context Protocol version that the server will use for this session. /// /// /// - /// This is the protocol version the server has agreed to use, which should match the client's + /// This is the initialize-capable protocol version the server has agreed to use, which should match the client's /// requested version. If there's a mismatch, the client should throw an exception to prevent /// communication issues due to incompatible protocol versions. /// diff --git a/src/ModelContextProtocol.Core/Protocol/InputRequest.cs b/src/ModelContextProtocol.Core/Protocol/InputRequest.cs new file mode 100644 index 000000000..1757fa6f6 --- /dev/null +++ b/src/ModelContextProtocol.Core/Protocol/InputRequest.cs @@ -0,0 +1,199 @@ +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace ModelContextProtocol.Protocol; + +/// +/// Represents a server-initiated request that the client must fulfill as part of an MRTR +/// (Multi Round-Trip Request) flow. +/// +/// +/// +/// An wraps a server-to-client request such as +/// , , +/// or . It is included in an +/// when the server needs additional input before it can complete a client-initiated request. +/// +/// +/// The property identifies the type of request, and the corresponding +/// parameters can be accessed via the typed accessor properties. +/// +/// +[JsonConverter(typeof(Converter))] +public sealed class InputRequest +{ + /// + /// Gets or sets the method name identifying the type of this input request. + /// + /// + /// Standard values include: + /// + /// A sampling request. + /// An elicitation request. + /// A roots list request. + /// + /// + [JsonPropertyName("method")] + public required string Method { get; set; } + + /// + /// Gets or sets the raw JSON parameters for this input request. + /// + /// + /// Use the typed accessor properties (, , + /// ) for convenient strongly-typed access. + /// + [JsonPropertyName("params")] + public JsonElement? Params { get; set; } + + /// + /// Gets the parameters as when + /// is . + /// + /// The deserialized sampling parameters, or if the method does not match or params are absent. + [JsonIgnore] + [Obsolete(Obsoletions.DeprecatedSampling_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] + public CreateMessageRequestParams? SamplingParams => + string.Equals(Method, RequestMethods.SamplingCreateMessage, StringComparison.Ordinal) && Params is { } p + ? JsonSerializer.Deserialize(p, McpJsonUtilities.JsonContext.Default.CreateMessageRequestParams) + : null; + + /// + /// Gets the parameters as when + /// is . + /// + /// The deserialized elicitation parameters, or if the method does not match or params are absent. + [JsonIgnore] + public ElicitRequestParams? ElicitationParams => + string.Equals(Method, RequestMethods.ElicitationCreate, StringComparison.Ordinal) && Params is { } p + ? JsonSerializer.Deserialize(p, McpJsonUtilities.JsonContext.Default.ElicitRequestParams) + : null; + + /// + /// Gets the parameters as when + /// is . + /// + /// The deserialized roots list parameters, or if the method does not match or params are absent. + [JsonIgnore] + [Obsolete(Obsoletions.DeprecatedRoots_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] + public ListRootsRequestParams? RootsParams => + string.Equals(Method, RequestMethods.RootsList, StringComparison.Ordinal) && Params is { } p + ? JsonSerializer.Deserialize(p, McpJsonUtilities.JsonContext.Default.ListRootsRequestParams) + : null; + + /// + /// Creates an for a sampling request. + /// + /// The sampling request parameters. + /// A new instance. + [Obsolete(Obsoletions.DeprecatedSampling_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] + public static InputRequest ForSampling(CreateMessageRequestParams requestParams) + { + Throw.IfNull(requestParams); + return new() + { + Method = RequestMethods.SamplingCreateMessage, + Params = JsonSerializer.SerializeToElement(requestParams, McpJsonUtilities.JsonContext.Default.CreateMessageRequestParams), + }; + } + + /// + /// Creates an for an elicitation request. + /// + /// The elicitation request parameters. + /// A new instance. + public static InputRequest ForElicitation(ElicitRequestParams requestParams) + { + Throw.IfNull(requestParams); + return new() + { + Method = RequestMethods.ElicitationCreate, + Params = JsonSerializer.SerializeToElement(requestParams, McpJsonUtilities.JsonContext.Default.ElicitRequestParams), + }; + } + + /// + /// Creates an for a roots list request. + /// + /// The roots list request parameters. + /// A new instance. + [Obsolete(Obsoletions.DeprecatedRoots_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] + public static InputRequest ForRootsList(ListRootsRequestParams requestParams) + { + Throw.IfNull(requestParams); + return new() + { + Method = RequestMethods.RootsList, + Params = JsonSerializer.SerializeToElement(requestParams, McpJsonUtilities.JsonContext.Default.ListRootsRequestParams), + }; + } + + /// Provides JSON serialization support for . + public sealed class Converter : JsonConverter + { + /// + public override InputRequest? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + if (reader.TokenType != JsonTokenType.StartObject) + { + throw new JsonException("Expected StartObject token."); + } + + string? method = null; + JsonElement? parameters = null; + + while (reader.Read()) + { + if (reader.TokenType == JsonTokenType.EndObject) + { + break; + } + + if (reader.TokenType != JsonTokenType.PropertyName) + { + throw new JsonException("Expected PropertyName token."); + } + + string propertyName = reader.GetString()!; + reader.Read(); + + switch (propertyName) + { + case "method": + method = reader.GetString(); + break; + case "params": + parameters = JsonElement.ParseValue(ref reader); + break; + default: + reader.Skip(); + break; + } + } + + if (method is null) + { + throw new JsonException("InputRequest must have a 'method' property."); + } + + return new InputRequest + { + Method = method, + Params = parameters, + }; + } + + /// + public override void Write(Utf8JsonWriter writer, InputRequest value, JsonSerializerOptions options) + { + writer.WriteStartObject(); + writer.WriteString("method", value.Method); + if (value.Params is { } p) + { + writer.WritePropertyName("params"); + p.WriteTo(writer); + } + writer.WriteEndObject(); + } + } +} diff --git a/src/ModelContextProtocol.Core/Protocol/InputRequiredException.cs b/src/ModelContextProtocol.Core/Protocol/InputRequiredException.cs new file mode 100644 index 000000000..89f2e538e --- /dev/null +++ b/src/ModelContextProtocol.Core/Protocol/InputRequiredException.cs @@ -0,0 +1,106 @@ +namespace ModelContextProtocol.Protocol; + +/// +/// The exception that is thrown by a server handler to return an +/// to the client, signaling that additional input is needed before the request can be completed. +/// +/// +/// +/// This exception is part of the Multi Round-Trip Requests (MRTR) API. Tool handlers +/// throw this exception to directly control the input-required result payload, including +/// and . +/// +/// +/// For stateless servers, this enables multi-round-trip flows without requiring the handler to stay +/// alive between round trips. The server encodes its state in +/// and receives it back on retry via . +/// +/// +/// To return a requestState-only response (e.g., for load shedding), omit +/// and set only . +/// The client will retry the request with the state echoed back. +/// +/// +/// This exception can only be used when MRTR is supported by the client. Check +/// before throwing. If thrown when MRTR is not +/// supported, the exception will propagate as a JSON-RPC internal error. +/// +/// +/// +/// +/// [McpServerTool, Description("A stateless tool using MRTR")] +/// public static string MyTool(McpServer server, RequestContext<CallToolRequestParams> context) +/// { +/// if (context.Params.RequestState is { } state) +/// { +/// // Retry: process accumulated state and input responses +/// var responses = context.Params.InputResponses; +/// return "Final result"; +/// } +/// +/// if (!server.IsMrtrSupported) +/// { +/// return "This tool requires MRTR support."; +/// } +/// +/// throw new InputRequiredException( +/// inputRequests: new Dictionary<string, InputRequest> +/// { +/// ["user_input"] = InputRequest.ForElicitation(new ElicitRequestParams { ... }) +/// }, +/// requestState: "encoded-state"); +/// } +/// +/// +public class InputRequiredException : Exception +{ + /// + /// Initializes a new instance of the class + /// with the specified . + /// + /// The input-required result to return to the client. + public InputRequiredException(InputRequiredResult result) + : base("The server returned an input-required result requiring additional client input.") + { + Throw.IfNull(result); + Result = result; + } + + /// + /// Initializes a new instance of the class + /// with the specified input requests and/or request state. + /// + /// + /// Server-initiated requests that the client must fulfill before retrying. + /// Keys are server-assigned identifiers. + /// + /// + /// Opaque state to be echoed back by the client when retrying. The client must + /// treat this as an opaque blob and must not inspect or modify it. + /// + /// + /// Both and are . + /// At least one must be provided. + /// + public InputRequiredException( + IDictionary? inputRequests = null, + string? requestState = null) + : base("The server returned an input-required result requiring additional client input.") + { + if (inputRequests is null && requestState is null) + { + throw new ArgumentException("At least one of inputRequests or requestState must be provided."); + } + + Result = new InputRequiredResult + { + InputRequests = inputRequests, + RequestState = requestState, + }; + } + + /// + /// Gets the input-required result to return to the client. + /// + public InputRequiredResult Result { get; } +} diff --git a/src/ModelContextProtocol.Core/Protocol/InputRequiredResult.cs b/src/ModelContextProtocol.Core/Protocol/InputRequiredResult.cs new file mode 100644 index 000000000..e82c3ec4d --- /dev/null +++ b/src/ModelContextProtocol.Core/Protocol/InputRequiredResult.cs @@ -0,0 +1,63 @@ +using System.Text.Json.Serialization; + +namespace ModelContextProtocol.Protocol; + +/// +/// Represents an input-required result sent by the server to indicate that additional input is needed +/// before the request can be completed. +/// +/// +/// +/// An is returned in response to a client-initiated request when +/// the server needs the client to fulfill one or more server-initiated requests before it can produce +/// a final result. Per SEP-2322 the wire format is valid for , +/// , and resources/read; this SDK wires the MRTR +/// interceptor into all three methods. +/// +/// +/// At least one of or must be present. +/// +/// +/// This type is part of the Multi Round-Trip Requests (MRTR) mechanism defined in SEP-2322. +/// +/// +public sealed class InputRequiredResult : Result +{ + /// + /// Initializes a new instance of the class. + /// + public InputRequiredResult() + { + ResultType = "input_required"; + } + + /// + /// Gets or sets the server-initiated requests that the client must fulfill before retrying the original request. + /// + /// + /// + /// The keys are server-assigned identifiers. The client must include a response for each key in the + /// map when retrying the original request. + /// + /// + [JsonPropertyName("inputRequests")] + public IDictionary? InputRequests { get; set; } + + /// + /// Gets or sets opaque state to be echoed back by the client when retrying the original request. + /// + /// + /// + /// The client must treat this as an opaque blob and must not inspect, parse, modify, or make + /// any assumptions about the contents. If present, the client must include this value in the + /// property when retrying the original request. + /// + /// + /// Servers may encode request state in any format (e.g., plain JSON, base64-encoded JSON, + /// encrypted JWT, serialized binary). If the state contains sensitive data, servers should + /// encrypt it to ensure confidentiality and integrity. + /// + /// + [JsonPropertyName("requestState")] + public string? RequestState { get; set; } +} diff --git a/src/ModelContextProtocol.Core/Protocol/InputResponse.cs b/src/ModelContextProtocol.Core/Protocol/InputResponse.cs new file mode 100644 index 000000000..24081c06e --- /dev/null +++ b/src/ModelContextProtocol.Core/Protocol/InputResponse.cs @@ -0,0 +1,130 @@ +using System.Text.Json; +using System.Text.Json.Serialization; +using System.Text.Json.Serialization.Metadata; + +namespace ModelContextProtocol.Protocol; + +/// +/// Represents a client's response to a server-initiated as part of an MRTR +/// (Multi Round-Trip Request) flow. +/// +/// +/// +/// An wraps the result of a server-to-client request such as +/// , , or . +/// The type of the inner response corresponds to the of the +/// associated input request. +/// +/// +/// The input response does not carry its own type discriminator in JSON. The type is determined by +/// the corresponding key in the map. +/// +/// +[JsonConverter(typeof(Converter))] +public sealed class InputResponse +{ + /// + /// Gets or sets the raw JSON element representing the response. + /// + /// + /// Use with the JsonTypeInfo<T> matching the + /// associated - for elicitation, sampling, or roots see + /// , , and + /// . + /// + [JsonIgnore] + public JsonElement RawValue { get; set; } + + /// + /// Deserializes the raw value to the specified result type. + /// + /// The type to deserialize to (e.g., , ). + /// The JSON type information for . + /// The deserialized result, or if deserialization fails. + public T? Deserialize(System.Text.Json.Serialization.Metadata.JsonTypeInfo typeInfo) => + JsonSerializer.Deserialize(RawValue, typeInfo); + + /// + /// Gets the for , suitable for use with + /// when the corresponding is + /// . + /// + public static JsonTypeInfo ElicitResultJsonTypeInfo => McpJsonUtilities.JsonContext.Default.ElicitResult; + + /// + /// Gets the for , suitable for use with + /// when the corresponding is + /// . + /// + [Obsolete(Obsoletions.DeprecatedSampling_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] + public static JsonTypeInfo CreateMessageResultJsonTypeInfo => McpJsonUtilities.JsonContext.Default.CreateMessageResult; + + /// + /// Gets the for , suitable for use with + /// when the corresponding is + /// . + /// + [Obsolete(Obsoletions.DeprecatedRoots_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] + public static JsonTypeInfo ListRootsResultJsonTypeInfo => McpJsonUtilities.JsonContext.Default.ListRootsResult; + + /// + /// Creates an from a . + /// + /// The sampling result. + /// A new instance. + [Obsolete(Obsoletions.DeprecatedSampling_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] + public static InputResponse FromSamplingResult(CreateMessageResult result) + { + Throw.IfNull(result); + return new() + { + RawValue = JsonSerializer.SerializeToElement(result, McpJsonUtilities.JsonContext.Default.CreateMessageResult), + }; + } + + /// + /// Creates an from an . + /// + /// The elicitation result. + /// A new instance. + public static InputResponse FromElicitResult(ElicitResult result) + { + Throw.IfNull(result); + return new() + { + RawValue = JsonSerializer.SerializeToElement(result, McpJsonUtilities.JsonContext.Default.ElicitResult), + }; + } + + /// + /// Creates an from a . + /// + /// The roots list result. + /// A new instance. + [Obsolete(Obsoletions.DeprecatedRoots_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] + public static InputResponse FromRootsResult(ListRootsResult result) + { + Throw.IfNull(result); + return new() + { + RawValue = JsonSerializer.SerializeToElement(result, McpJsonUtilities.JsonContext.Default.ListRootsResult), + }; + } + + /// Provides JSON serialization support for . + public sealed class Converter : JsonConverter + { + /// + public override InputResponse? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + var element = JsonElement.ParseValue(ref reader); + return new InputResponse { RawValue = element }; + } + + /// + public override void Write(Utf8JsonWriter writer, InputResponse value, JsonSerializerOptions options) + { + value.RawValue.WriteTo(writer); + } + } +} diff --git a/src/ModelContextProtocol.Core/Protocol/JsonRpcMessage.cs b/src/ModelContextProtocol.Core/Protocol/JsonRpcMessage.cs index 1dfef5de1..0daeb010a 100644 --- a/src/ModelContextProtocol.Core/Protocol/JsonRpcMessage.cs +++ b/src/ModelContextProtocol.Core/Protocol/JsonRpcMessage.cs @@ -83,6 +83,7 @@ public sealed class Converter : JsonConverter // Local variables for parsed message data bool hasJsonRpc = false; RequestId id = default; + bool hasId = false; string? method = null; JsonNode? parameters = null; JsonRpcErrorDetail? error = null; @@ -118,6 +119,7 @@ public sealed class Converter : JsonConverter case "id": id = JsonSerializer.Deserialize(ref reader, options.GetTypeInfo()); + hasId = true; break; case "method": @@ -153,6 +155,16 @@ public sealed class Converter : JsonConverter // Determine message type based on presence of id and method properties if (method is not null) { + if (hasId && id.Id is null) + { + // A request that carries an explicit `id: null` is malformed. The MCP base protocol + // states "Unlike base JSON-RPC, the ID MUST NOT be null", and a null id does NOT denote + // a notification — per JSON-RPC 2.0 a Notification is a Request object *without* an id + // member. Reject it rather than silently downgrading to a notification (which would + // drop the malformed id and skip sending any response). + throw new JsonException("Request id must not be null. Per MCP, a request id must be a non-null string or number; omit the id member entirely to send a notification."); + } + if (id.Id is not null) { // Messages with both method and id are requests @@ -165,7 +177,7 @@ public sealed class Converter : JsonConverter } else { - // Messages with a method but no id are notifications + // Messages with a method but no id member are notifications return new JsonRpcNotification { Method = method, @@ -200,6 +212,19 @@ public sealed class Converter : JsonConverter throw new JsonException("Response must have either result or error"); } + if (error is not null) + { + // Per JSON-RPC 2.0, when an error occurs before the request id can be determined + // (e.g. parse error or invalid request), the server MUST respond with id=null. + // Accept null-id error responses so callers can recognize the structured signal + // (e.g. an HTTP 400 body whose JSON-RPC envelope carries a non-SEP-2575 error code). + return new JsonRpcError + { + Id = id, + Error = error + }; + } + // Error: Messages with neither id nor method are invalid throw new JsonException("Invalid JSON-RPC message format"); } diff --git a/src/ModelContextProtocol.Core/Protocol/JsonRpcMessageContext.cs b/src/ModelContextProtocol.Core/Protocol/JsonRpcMessageContext.cs index 2fa9839f0..def9b89e4 100644 --- a/src/ModelContextProtocol.Core/Protocol/JsonRpcMessageContext.cs +++ b/src/ModelContextProtocol.Core/Protocol/JsonRpcMessageContext.cs @@ -1,4 +1,5 @@ using ModelContextProtocol.Server; +using System.Diagnostics.CodeAnalysis; using System.Security.Claims; using System.Text.Json.Serialization; @@ -74,4 +75,57 @@ public sealed class JsonRpcMessageContext /// /// public IDictionary? Items { get; set; } + + /// + /// Gets or sets the routing name for this message. + /// + /// + /// Streamable HTTP transports emit this value in the Mcp-Name header. This enables + /// extension methods to identify the named resource targeted by a request. + /// + [Experimental(Experimentals.Extensibility_DiagnosticId, UrlFormat = Experimentals.Extensibility_Url)] + [JsonIgnore] + public string? RoutingName { get; set; } + + /// + /// Gets or sets the protocol version from the transport-level header (e.g. Mcp-Protocol-Version) + /// that accompanied this JSON-RPC message. + /// + /// + /// In stateless Streamable HTTP mode, the protocol version cannot be negotiated via the initialize + /// handshake because each request creates a new server instance. This property allows the transport layer + /// to flow the protocol version header so the server can determine client capabilities. + /// + public string? ProtocolVersion { get; set; } + + /// + /// Gets or sets the client info derived from the per-request + /// _meta/io.modelcontextprotocol/clientInfo field. + /// + /// + /// Introduced by the 2026-07-28 protocol revision (SEP-2575). When the request was made under the 2026-07-28 or later revision, + /// the server uses this in lieu of the value previously captured during the initialize handshake. + /// + public Implementation? ClientInfo { get; set; } + + /// + /// Gets or sets the client capabilities derived from the per-request + /// _meta/io.modelcontextprotocol/clientCapabilities field. + /// + /// + /// Introduced by the 2026-07-28 protocol revision (SEP-2575). Per the spec, the server MUST NOT infer client + /// capabilities from previous requests; the authoritative value is the one declared on each request. + /// + public ClientCapabilities? ClientCapabilities { get; set; } + + /// + /// Gets or sets the per-request log level derived from the + /// _meta/io.modelcontextprotocol/logLevel field. + /// + /// + /// Introduced by the 2026-07-28 protocol revision (SEP-2575). Replaces the legacy + /// RPC. When absent, the server MUST NOT emit log notifications + /// for the request. + /// + public LoggingLevel? LogLevel { get; set; } } diff --git a/src/ModelContextProtocol.Core/Protocol/ListPromptsResult.cs b/src/ModelContextProtocol.Core/Protocol/ListPromptsResult.cs index 1f648bd5a..a7f26b521 100644 --- a/src/ModelContextProtocol.Core/Protocol/ListPromptsResult.cs +++ b/src/ModelContextProtocol.Core/Protocol/ListPromptsResult.cs @@ -18,11 +18,21 @@ namespace ModelContextProtocol.Protocol; /// See the schema for details. /// /// -public sealed class ListPromptsResult : PaginatedResult +public sealed class ListPromptsResult : PaginatedResult, ICacheableResult { /// /// Gets or sets a list of prompts or prompt templates that the server offers. /// [JsonPropertyName("prompts")] public IList Prompts { get; set; } = []; + + /// + [JsonPropertyName("ttlMs")] + [JsonConverter(typeof(TimeSpanMillisecondsConverter))] + public TimeSpan? TimeToLive { get; set; } + + /// + [JsonPropertyName("cacheScope")] + [JsonConverter(typeof(CacheScopeConverter))] + public CacheScope? CacheScope { get; set; } } diff --git a/src/ModelContextProtocol.Core/Protocol/ListResourceTemplatesResult.cs b/src/ModelContextProtocol.Core/Protocol/ListResourceTemplatesResult.cs index 6e422a751..988d6f186 100644 --- a/src/ModelContextProtocol.Core/Protocol/ListResourceTemplatesResult.cs +++ b/src/ModelContextProtocol.Core/Protocol/ListResourceTemplatesResult.cs @@ -20,7 +20,7 @@ namespace ModelContextProtocol.Protocol; /// See the schema for details. /// /// -public sealed class ListResourceTemplatesResult : PaginatedResult +public sealed class ListResourceTemplatesResult : PaginatedResult, ICacheableResult { /// /// Gets or sets a list of resource templates that the server offers. @@ -32,4 +32,14 @@ public sealed class ListResourceTemplatesResult : PaginatedResult /// [JsonPropertyName("resourceTemplates")] public IList ResourceTemplates { get; set; } = []; + + /// + [JsonPropertyName("ttlMs")] + [JsonConverter(typeof(TimeSpanMillisecondsConverter))] + public TimeSpan? TimeToLive { get; set; } + + /// + [JsonPropertyName("cacheScope")] + [JsonConverter(typeof(CacheScopeConverter))] + public CacheScope? CacheScope { get; set; } } \ No newline at end of file diff --git a/src/ModelContextProtocol.Core/Protocol/ListResourcesResult.cs b/src/ModelContextProtocol.Core/Protocol/ListResourcesResult.cs index 16d01491c..54c1df601 100644 --- a/src/ModelContextProtocol.Core/Protocol/ListResourcesResult.cs +++ b/src/ModelContextProtocol.Core/Protocol/ListResourcesResult.cs @@ -18,11 +18,21 @@ namespace ModelContextProtocol.Protocol; /// See the schema for details. /// /// -public sealed class ListResourcesResult : PaginatedResult +public sealed class ListResourcesResult : PaginatedResult, ICacheableResult { /// /// Gets or sets a list of resources that the server offers. /// [JsonPropertyName("resources")] public IList Resources { get; set; } = []; + + /// + [JsonPropertyName("ttlMs")] + [JsonConverter(typeof(TimeSpanMillisecondsConverter))] + public TimeSpan? TimeToLive { get; set; } + + /// + [JsonPropertyName("cacheScope")] + [JsonConverter(typeof(CacheScopeConverter))] + public CacheScope? CacheScope { get; set; } } diff --git a/src/ModelContextProtocol.Core/Protocol/ListRootsRequestParams.cs b/src/ModelContextProtocol.Core/Protocol/ListRootsRequestParams.cs index 5f3bf5d0f..602ee502b 100644 --- a/src/ModelContextProtocol.Core/Protocol/ListRootsRequestParams.cs +++ b/src/ModelContextProtocol.Core/Protocol/ListRootsRequestParams.cs @@ -8,4 +8,5 @@ namespace ModelContextProtocol.Protocol; /// The client responds with a containing the client's roots. /// See the schema for details. /// +[Obsolete(Obsoletions.DeprecatedRoots_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public sealed class ListRootsRequestParams : RequestParams; diff --git a/src/ModelContextProtocol.Core/Protocol/ListRootsResult.cs b/src/ModelContextProtocol.Core/Protocol/ListRootsResult.cs index 115283e98..66debfef8 100644 --- a/src/ModelContextProtocol.Core/Protocol/ListRootsResult.cs +++ b/src/ModelContextProtocol.Core/Protocol/ListRootsResult.cs @@ -16,6 +16,7 @@ namespace ModelContextProtocol.Protocol; /// See the schema for details. /// /// +[Obsolete(Obsoletions.DeprecatedRoots_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public sealed class ListRootsResult : Result { /// diff --git a/src/ModelContextProtocol.Core/Protocol/ListTasksRequestParams.cs b/src/ModelContextProtocol.Core/Protocol/ListTasksRequestParams.cs deleted file mode 100644 index 3036d977b..000000000 --- a/src/ModelContextProtocol.Core/Protocol/ListTasksRequestParams.cs +++ /dev/null @@ -1,34 +0,0 @@ -using System.Diagnostics.CodeAnalysis; -using System.Text.Json.Serialization; - -namespace ModelContextProtocol.Protocol; - -/// -/// Represents the parameters for a tasks/list request to retrieve a list of tasks. -/// -/// -/// This operation supports cursor-based pagination. Receivers should use cursor-based -/// pagination to limit the number of tasks returned in a single response. -/// -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -public sealed class ListTasksRequestParams : PaginatedRequestParams -{ - // Inherits Cursor property from PaginatedRequestParams -} - -/// -/// Represents the result of a tasks/list request. -/// -/// -/// The result contains an array of task objects and an optional cursor for pagination. -/// If is present, more tasks are available. -/// -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -public sealed class ListTasksResult : PaginatedResult -{ - /// - /// Gets or sets the list of tasks. - /// - [JsonPropertyName("tasks")] - public required IList Tasks { get; set; } -} diff --git a/src/ModelContextProtocol.Core/Protocol/ListToolsResult.cs b/src/ModelContextProtocol.Core/Protocol/ListToolsResult.cs index a2f03b853..55eed5ddb 100644 --- a/src/ModelContextProtocol.Core/Protocol/ListToolsResult.cs +++ b/src/ModelContextProtocol.Core/Protocol/ListToolsResult.cs @@ -18,11 +18,21 @@ namespace ModelContextProtocol.Protocol; /// See the schema for details. /// /// -public sealed class ListToolsResult : PaginatedResult +public sealed class ListToolsResult : PaginatedResult, ICacheableResult { /// /// Gets or sets the server's response to a tools/list request from the client. /// [JsonPropertyName("tools")] public IList Tools { get; set; } = []; + + /// + [JsonPropertyName("ttlMs")] + [JsonConverter(typeof(TimeSpanMillisecondsConverter))] + public TimeSpan? TimeToLive { get; set; } + + /// + [JsonPropertyName("cacheScope")] + [JsonConverter(typeof(CacheScopeConverter))] + public CacheScope? CacheScope { get; set; } } diff --git a/src/ModelContextProtocol.Core/Protocol/LoggingCapability.cs b/src/ModelContextProtocol.Core/Protocol/LoggingCapability.cs index 18d8f0c28..f33072929 100644 --- a/src/ModelContextProtocol.Core/Protocol/LoggingCapability.cs +++ b/src/ModelContextProtocol.Core/Protocol/LoggingCapability.cs @@ -18,6 +18,7 @@ namespace ModelContextProtocol.Protocol; /// specification may extend this capability with additional configuration options. /// /// +[Obsolete(Obsoletions.DeprecatedLogging_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public sealed class LoggingCapability { } \ No newline at end of file diff --git a/src/ModelContextProtocol.Core/Protocol/LoggingLevel.cs b/src/ModelContextProtocol.Core/Protocol/LoggingLevel.cs index 5fadf7fbc..c8d39064c 100644 --- a/src/ModelContextProtocol.Core/Protocol/LoggingLevel.cs +++ b/src/ModelContextProtocol.Core/Protocol/LoggingLevel.cs @@ -1,4 +1,4 @@ -using System.Text.Json.Serialization; +using System.Text.Json.Serialization; namespace ModelContextProtocol.Protocol; @@ -9,6 +9,7 @@ namespace ModelContextProtocol.Protocol; /// These values map to syslog message severities, as specified in RFC-5424. /// [JsonConverter(typeof(JsonStringEnumConverter))] +[Obsolete(Obsoletions.DeprecatedLogging_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public enum LoggingLevel { /// Detailed debug information, typically only valuable to developers. diff --git a/src/ModelContextProtocol.Core/Protocol/LoggingMessageNotificationParams.cs b/src/ModelContextProtocol.Core/Protocol/LoggingMessageNotificationParams.cs index 600f620a5..0840c9c7c 100644 --- a/src/ModelContextProtocol.Core/Protocol/LoggingMessageNotificationParams.cs +++ b/src/ModelContextProtocol.Core/Protocol/LoggingMessageNotificationParams.cs @@ -20,6 +20,7 @@ namespace ModelContextProtocol.Protocol; /// See the schema for details. /// /// +[Obsolete(Obsoletions.DeprecatedLogging_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public sealed class LoggingMessageNotificationParams : NotificationParams { /// diff --git a/src/ModelContextProtocol.Core/Protocol/McpHeaderEncoder.cs b/src/ModelContextProtocol.Core/Protocol/McpHeaderEncoder.cs new file mode 100644 index 000000000..904f4db00 --- /dev/null +++ b/src/ModelContextProtocol.Core/Protocol/McpHeaderEncoder.cs @@ -0,0 +1,256 @@ +using System.Text; +using System.Text.Json; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.Protocol; + +/// +/// Encodes and decodes parameter values for use in MCP HTTP headers according to the +/// HTTP Standardization SEP. +/// +/// +/// +/// This encoder handles conversion of parameter values to HTTP header-safe strings, +/// including Base64 encoding for values that cannot be safely transmitted as plain text. +/// +/// +/// Per SEP-2243 only primitive parameter types are supported: string, integer, and +/// boolean. The JSON Schema number type is not permitted, and integer values must be +/// within the JavaScript safe integer range (−2^53+1 to 2^53−1). +/// +/// +/// Encoding rules: +/// +/// Plain ASCII values (0x20-0x7E): sent as-is +/// Values with leading/trailing whitespace: Base64 encoded with =?base64?{value}?= wrapper +/// Non-ASCII characters: Base64 encoded +/// Control characters: Base64 encoded +/// Plain ASCII values that themselves match the =?base64?...?= sentinel pattern: Base64 encoded to avoid ambiguity +/// +/// +/// +public static class McpHeaderEncoder +{ + private const string Base64Prefix = "=?base64?"; + private const string Base64Suffix = "?="; + + // Strict UTF-8 decoder that throws on invalid byte sequences rather than silently substituting + // U+FFFD replacement characters, so a malformed Base64-wrapped header value is rejected. + private static readonly UTF8Encoding s_strictUtf8 = new(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true); + + /// + /// Encodes a string parameter value for use in an HTTP header. + /// + /// The string value to encode. + /// + /// The encoded header value, or if is . + /// + public static string? EncodeValue(string? value) + { + if (value is null) + { + return null; + } + + if (RequiresBase64Encoding(value)) + { + return EncodeAsBase64(value); + } + + return value; + } + + /// + /// Encodes a boolean parameter value for use in an HTTP header. + /// + /// The boolean value to encode. + /// The encoded header value ("true" or "false"). + public static string EncodeValue(bool value) => value ? "true" : "false"; + + /// + /// Encodes an integer parameter value for use in an HTTP header. + /// + /// The integer value to encode. + /// The decimal string representation of the value. + public static string EncodeValue(long value) => value.ToString(System.Globalization.CultureInfo.InvariantCulture); + + /// + /// Encodes a parameter value for use in an HTTP header. + /// + /// The value to encode. Supported types are string, integer, and boolean. + /// + /// The encoded header value, or if the value is + /// or is not a supported type (string, integer, or boolean). + /// + public static string? EncodeValue(object? value) + { + if (value is null) + { + return null; + } + + // Route to typed overloads for known types + if (value is string s) + { + return EncodeValue(s); + } + + if (value is bool b) + { + return EncodeValue(b); + } + + var stringValue = ConvertToString(value); + if (stringValue is null) + { + return null; + } + + return stringValue; + } + + /// + /// Decodes a header value that may be Base64-encoded according to SEP rules. + /// + /// The header value to decode. + /// + /// The decoded string value, or if decoding fails. + /// If the value is not Base64-encoded, returns the original value. + /// + public static string? DecodeValue(string? headerValue) + { + if (headerValue is null || headerValue.Length == 0) + { + return headerValue; + } + + // Check for Base64 wrapper. The spec requires the sentinel markers to be + // case-sensitive and exactly lowercase per SEP-2243. + if (headerValue.Length >= Base64Prefix.Length + Base64Suffix.Length && + headerValue.StartsWith(Base64Prefix, StringComparison.Ordinal) && + headerValue.EndsWith(Base64Suffix, StringComparison.Ordinal)) + { + var base64Content = headerValue.Substring( + Base64Prefix.Length, + headerValue.Length - Base64Prefix.Length - Base64Suffix.Length); + + try + { + var bytes = Convert.FromBase64String(base64Content); + return s_strictUtf8.GetString(bytes); + } + catch (FormatException) + { + return null; + } + catch (DecoderFallbackException) + { + return null; + } + } + + return headerValue; + } + + /// + /// Converts a value to an encoded header value string. + /// + /// The JSON element to convert. + /// The encoded header value, or if the element is not a supported primitive type. + public static string? ConvertToHeaderValue(JsonElement element) + { + object? value = element.ValueKind switch + { + JsonValueKind.String => element.GetString(), + JsonValueKind.Number => element.GetRawText(), + JsonValueKind.True => true, + JsonValueKind.False => false, + _ => null + }; + + return EncodeValue(value); + } + + /// + /// Converts a value to an encoded header value string. + /// + /// The JSON node to convert. + /// The encoded header value, or if the node is not a or is not a supported primitive type. + public static string? ConvertToHeaderValue(JsonNode node) + { + if (node is not JsonValue jsonValue) + { + return null; + } + + object? value = jsonValue.GetValueKind() switch + { + JsonValueKind.String => jsonValue.GetValue(), + JsonValueKind.Number => jsonValue.ToJsonString(), + JsonValueKind.True => true, + JsonValueKind.False => false, + _ => null + }; + + return EncodeValue(value); + } + + private static string? ConvertToString(object value) + { + return value switch + { + string s => s, + bool b => b ? "true" : "false", + byte n => n.ToString(System.Globalization.CultureInfo.InvariantCulture), + sbyte n => n.ToString(System.Globalization.CultureInfo.InvariantCulture), + short n => n.ToString(System.Globalization.CultureInfo.InvariantCulture), + ushort n => n.ToString(System.Globalization.CultureInfo.InvariantCulture), + int n => n.ToString(System.Globalization.CultureInfo.InvariantCulture), + uint n => n.ToString(System.Globalization.CultureInfo.InvariantCulture), + long n => n.ToString(System.Globalization.CultureInfo.InvariantCulture), + ulong n => n.ToString(System.Globalization.CultureInfo.InvariantCulture), + _ => null + }; + } + + private static bool RequiresBase64Encoding(string value) + { + if (value.Length == 0) + { + return false; + } + + // Check for leading/trailing whitespace (space or tab) + if (value[0] is ' ' or '\t' || value[^1] is ' ' or '\t') + { + return true; + } + + // Avoid sentinel collision: if the value matches the base64 wrapper pattern, + // it must be encoded to prevent ambiguity during decoding. + if (value.StartsWith(Base64Prefix, StringComparison.Ordinal) && + value.EndsWith(Base64Suffix, StringComparison.Ordinal)) + { + return true; + } + + foreach (char c in value) + { + // Valid HTTP header field value characters per SEP: visible ASCII (0x21-0x7E) and space (0x20). + // All control characters (0x00-0x1F, 0x7F), including tab, must be Base64-encoded. + if (c < 0x20 || c > 0x7E) + { + return true; + } + } + + return false; + } + + private static string EncodeAsBase64(string value) + { + var bytes = Encoding.UTF8.GetBytes(value); + var base64 = Convert.ToBase64String(bytes); + return $"{Base64Prefix}{base64}{Base64Suffix}"; + } +} diff --git a/src/ModelContextProtocol.Core/Protocol/McpTask.cs b/src/ModelContextProtocol.Core/Protocol/McpTask.cs deleted file mode 100644 index 2056c5890..000000000 --- a/src/ModelContextProtocol.Core/Protocol/McpTask.cs +++ /dev/null @@ -1,104 +0,0 @@ -using System.Diagnostics; -using System.Diagnostics.CodeAnalysis; -using System.Text.Json.Serialization; - -namespace ModelContextProtocol.Protocol; - -/// -/// Represents an MCP task, which is a durable state machine carrying information -/// about the underlying execution state of a request. -/// -/// -/// -/// Tasks are useful for representing expensive computations and batch processing requests. -/// Each task is uniquely identifiable by a receiver-generated task ID. -/// -/// -/// Tasks follow a defined lifecycle through the property. They begin -/// in the status and may transition through various states -/// before reaching a terminal status (, , -/// or ). -/// -/// -/// See the tasks specification for details. -/// -/// -[DebuggerDisplay("{DebuggerDisplay,nq}")] -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -public sealed class McpTask -{ - /// - /// Gets or sets the unique identifier for the task. - /// - /// - /// Task IDs are generated by the receiver when creating a task and must be unique - /// among all tasks controlled by that receiver. - /// - [JsonPropertyName("taskId")] - public required string TaskId { get; set; } - - /// - /// Gets or sets the current state of the task execution. - /// - [JsonPropertyName("status")] - public required McpTaskStatus Status { get; set; } - - /// - /// Gets or sets an optional human-readable message describing the current state. - /// - /// - /// This message can be present for any status, including error details for failed tasks. - /// - [JsonPropertyName("statusMessage")] - public string? StatusMessage { get; set; } - - /// - /// Gets or sets the ISO 8601 timestamp when the task was created. - /// - /// - /// Receivers must include this timestamp in all task responses to indicate when - /// the task was created. - /// - [JsonPropertyName("createdAt")] - public required DateTimeOffset CreatedAt { get; set; } - - /// - /// Gets or sets the ISO 8601 timestamp when the task status was last updated. - /// - /// - /// Receivers must include this timestamp in all task responses to indicate when - /// the task was last updated. - /// - [JsonPropertyName("lastUpdatedAt")] - public required DateTimeOffset LastUpdatedAt { get; set; } - - /// - /// Gets or sets the time to live (retention duration) from creation before the task may be deleted. - /// - /// - /// - /// A null value indicates unlimited lifetime. After a task's TTL lifetime has elapsed, - /// receivers may delete the task and its results, regardless of the task status. - /// - /// - /// Receivers may override the requested TTL duration and must include the actual TTL - /// duration (or null for unlimited) in task responses. - /// - /// - [JsonPropertyName("ttl")] - [JsonConverter(typeof(TimeSpanMillisecondsConverter))] - public TimeSpan? TimeToLive { get; set; } - - /// - /// Gets or sets the suggested time between status checks. - /// - /// - /// Requestors should respect this value when provided to avoid excessive polling. - /// This value is optional and may not be present in all task responses. - /// - [JsonPropertyName("pollInterval")] - [JsonConverter(typeof(TimeSpanMillisecondsConverter))] - public TimeSpan? PollInterval { get; set; } - - private string DebuggerDisplay => $"Task {TaskId}: {Status}" + (StatusMessage != null ? $" - {StatusMessage}" : ""); -} diff --git a/src/ModelContextProtocol.Core/Protocol/McpTaskMetadata.cs b/src/ModelContextProtocol.Core/Protocol/McpTaskMetadata.cs deleted file mode 100644 index 72dea54f3..000000000 --- a/src/ModelContextProtocol.Core/Protocol/McpTaskMetadata.cs +++ /dev/null @@ -1,41 +0,0 @@ -using System.Diagnostics.CodeAnalysis; -using System.Text.Json.Serialization; - -namespace ModelContextProtocol.Protocol; - -/// -/// Represents metadata for augmenting a request with task execution. -/// -/// -/// -/// When included in a request's params, this metadata signals that the requestor -/// wants the receiver to execute the request as a task rather than synchronously. -/// The receiver will return a containing task data -/// instead of the actual operation result. -/// -/// -/// Requestors can specify a desired TTL (time-to-live) duration for the task, -/// though receivers may override this value based on their resource management policies. -/// -/// -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -public sealed class McpTaskMetadata -{ - /// - /// Gets or sets the requested time to live (retention duration) to retain the task from creation. - /// - /// - /// - /// This is a hint to the receiver about how long the requestor expects to need access - /// to the task data. Receivers may override this value based on their resource constraints - /// and policies. - /// - /// - /// A null value indicates no specific retention requirement. The actual TTL used by the - /// receiver will be returned in the property. - /// - /// - [JsonPropertyName("ttl")] - [JsonConverter(typeof(TimeSpanMillisecondsConverter))] - public TimeSpan? TimeToLive { get; set; } -} diff --git a/src/ModelContextProtocol.Core/Protocol/McpTaskStatus.cs b/src/ModelContextProtocol.Core/Protocol/McpTaskStatus.cs deleted file mode 100644 index 9cf8a2f66..000000000 --- a/src/ModelContextProtocol.Core/Protocol/McpTaskStatus.cs +++ /dev/null @@ -1,79 +0,0 @@ -using System.Diagnostics.CodeAnalysis; -using System.Text.Json.Serialization; - -namespace ModelContextProtocol.Protocol; - -/// -/// Represents the status of an MCP task. -/// -/// -/// -/// Tasks progress through a defined lifecycle: -/// -/// : The request is currently being processed. -/// : The receiver needs input from the requestor. -/// The requestor should call tasks/result to receive input requests. -/// : The request completed successfully and results are available. -/// : The request did not complete successfully. -/// : The request was cancelled before completion. -/// -/// -/// -/// Terminal states are , , and . -/// Once a task reaches a terminal state, it cannot transition to any other status. -/// -/// -[JsonConverter(typeof(JsonStringEnumConverter))] -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -public enum McpTaskStatus -{ - /// - /// The request is currently being processed. - /// - /// - /// Tasks begin in this status when created. From , tasks may transition - /// to , , , or . - /// - [JsonStringEnumMemberName("working")] - Working, - - /// - /// The receiver needs input from the requestor. - /// - /// - /// The requestor should call tasks/result to receive input requests, even though the task - /// has not reached a terminal state. From , tasks may transition - /// to , , , or . - /// - [JsonStringEnumMemberName("input_required")] - InputRequired, - - /// - /// The request completed successfully and results are available. - /// - /// - /// This is a terminal status. Tasks in this status cannot transition to any other status. - /// - [JsonStringEnumMemberName("completed")] - Completed, - - /// - /// The associated request did not complete successfully. - /// - /// - /// This is a terminal status. For tool calls specifically, this includes cases where - /// the tool call result has isError set to true. Tasks in this status cannot transition - /// to any other status. - /// - [JsonStringEnumMemberName("failed")] - Failed, - - /// - /// The request was cancelled before completion. - /// - /// - /// This is a terminal status. Tasks in this status cannot transition to any other status. - /// - [JsonStringEnumMemberName("cancelled")] - Cancelled -} diff --git a/src/ModelContextProtocol.Core/Protocol/McpTaskStatusNotificationParams.cs b/src/ModelContextProtocol.Core/Protocol/McpTaskStatusNotificationParams.cs deleted file mode 100644 index a9b536102..000000000 --- a/src/ModelContextProtocol.Core/Protocol/McpTaskStatusNotificationParams.cs +++ /dev/null @@ -1,67 +0,0 @@ -using System.Diagnostics.CodeAnalysis; -using System.Text.Json.Serialization; - -namespace ModelContextProtocol.Protocol; - -/// -/// Represents the parameters for a notifications/tasks/status notification. -/// -/// -/// -/// When a task status changes, receivers may send this notification to inform the -/// requestor of the change. This notification includes the full task state. -/// -/// -/// Requestors must not rely on receiving this notification, as it is optional. Receivers -/// are not required to send status notifications and may choose to only send them for -/// certain status transitions. Requestors should continue to poll via tasks/get to ensure -/// they receive status updates. -/// -/// -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -public sealed class McpTaskStatusNotificationParams : NotificationParams -{ - /// - /// Gets or sets the task ID. - /// - [JsonPropertyName("taskId")] - public required string TaskId { get; set; } - - /// - /// Gets or sets the current status of the task. - /// - [JsonPropertyName("status")] - public required McpTaskStatus Status { get; set; } - - /// - /// Gets or sets an optional human-readable message describing the current state. - /// - [JsonPropertyName("statusMessage")] - public string? StatusMessage { get; set; } - - /// - /// Gets or sets the ISO 8601 timestamp when the task was created. - /// - [JsonPropertyName("createdAt")] - public required DateTimeOffset CreatedAt { get; set; } - - /// - /// Gets or sets the ISO 8601 timestamp when the task status was last updated. - /// - [JsonPropertyName("lastUpdatedAt")] - public required DateTimeOffset LastUpdatedAt { get; set; } - - /// - /// Gets or sets the time to live (retention duration) from creation before the task may be deleted. - /// - [JsonPropertyName("ttl")] - [JsonConverter(typeof(TimeSpanMillisecondsConverter))] - public TimeSpan? TimeToLive { get; set; } - - /// - /// Gets or sets the suggested time between status checks. - /// - [JsonPropertyName("pollInterval")] - [JsonConverter(typeof(TimeSpanMillisecondsConverter))] - public TimeSpan? PollInterval { get; set; } -} diff --git a/src/ModelContextProtocol.Core/Protocol/McpTasksCapability.cs b/src/ModelContextProtocol.Core/Protocol/McpTasksCapability.cs deleted file mode 100644 index 1b3ccd9dd..000000000 --- a/src/ModelContextProtocol.Core/Protocol/McpTasksCapability.cs +++ /dev/null @@ -1,160 +0,0 @@ -using System.Diagnostics.CodeAnalysis; -using System.Text.Json.Serialization; - -namespace ModelContextProtocol.Protocol; - -/// -/// Represents the tasks capability configuration for servers and clients. -/// -/// -/// -/// The tasks capability enables requestors (clients or servers) to augment their requests with -/// tasks for long-running operations. Tasks are durable state machines that carry information -/// about the underlying execution state of requests. -/// -/// -/// During initialization, both parties exchange their tasks capabilities to establish which -/// operations support task-based execution. Requestors should only augment requests with a -/// task if the corresponding capability has been declared by the receiver. -/// -/// -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -public sealed class McpTasksCapability -{ - /// - /// Gets or sets whether this party supports the tasks/list operation. - /// - /// - /// When present, indicates support for listing all tasks. - /// - [JsonPropertyName("list")] - public ListMcpTasksCapability? List { get; set; } - - /// - /// Gets or sets whether this party supports the tasks/cancel operation. - /// - /// - /// When present, indicates support for cancelling tasks. - /// - [JsonPropertyName("cancel")] - public CancelMcpTasksCapability? Cancel { get; set; } - - /// - /// Gets or sets which request types support task augmentation. - /// - /// - /// - /// The set of capabilities in this property is exhaustive. If a request type is not present, - /// it does not support task augmentation. - /// - /// - /// For servers, this typically includes tools/call. For clients, this typically includes - /// sampling/createMessage and elicitation/create. - /// - /// - [JsonPropertyName("requests")] - public RequestMcpTasksCapability? Requests { get; set; } -} - -/// -/// Represents task support for tool-specific requests. -/// -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -public sealed class RequestMcpTasksCapability -{ - /// - /// Gets or sets task support for tool-related requests. - /// - [JsonPropertyName("tools")] - public ToolsMcpTasksCapability? Tools { get; set; } - - /// - /// Gets or sets task support for sampling-related requests. - /// - [JsonPropertyName("sampling")] - public SamplingMcpTasksCapability? Sampling { get; set; } - - /// - /// Gets or sets task support for elicitation-related requests. - /// - [JsonPropertyName("elicitation")] - public ElicitationMcpTasksCapability? Elicitation { get; set; } -} - -/// -/// Represents task support for tool-related requests. -/// -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -public sealed class ToolsMcpTasksCapability -{ - /// - /// Gets or sets whether tools/call requests support task augmentation. - /// - /// - /// When present, indicates that the server supports task-augmented tools/call requests. - /// - [JsonPropertyName("call")] - public CallToolMcpTasksCapability? Call { get; set; } -} - -/// -/// Represents task support for sampling-related requests. -/// -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -public sealed class SamplingMcpTasksCapability -{ - /// - /// Gets or sets whether sampling/createMessage requests support task augmentation. - /// - /// - /// When present, indicates that the client supports task-augmented sampling/createMessage requests. - /// - [JsonPropertyName("createMessage")] - public CreateMessageMcpTasksCapability? CreateMessage { get; set; } -} - -/// -/// Represents task support for elicitation-related requests. -/// -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -public sealed class ElicitationMcpTasksCapability -{ - /// - /// Gets or sets whether elicitation/create requests support task augmentation. - /// - /// - /// When present, indicates that the client supports task-augmented elicitation/create requests. - /// - [JsonPropertyName("create")] - public CreateElicitationMcpTasksCapability? Create { get; set; } -} - -/// -/// Represents the capability for listing tasks. -/// -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -public sealed class ListMcpTasksCapability; - -/// -/// Represents the capability for cancelling tasks. -/// -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -public sealed class CancelMcpTasksCapability; - -/// -/// Represents the capability for task-augmented tools/call requests. -/// -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -public sealed class CallToolMcpTasksCapability; - -/// -/// Represents the capability for task-augmented sampling/createMessage requests. -/// -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -public sealed class CreateMessageMcpTasksCapability; - -/// -/// Represents the capability for task-augmented elicitation/create requests. -/// -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -public sealed class CreateElicitationMcpTasksCapability; diff --git a/src/ModelContextProtocol.Core/Protocol/MetaKeys.cs b/src/ModelContextProtocol.Core/Protocol/MetaKeys.cs new file mode 100644 index 000000000..9605bab6b --- /dev/null +++ b/src/ModelContextProtocol.Core/Protocol/MetaKeys.cs @@ -0,0 +1,66 @@ +namespace ModelContextProtocol.Protocol; + +/// +/// Provides constants for well-known _meta field keys defined by the MCP protocol and its extensions. +/// +public static class MetaKeys +{ + /// + /// The metadata key used to carry the MCP protocol version in a request's _meta field. + /// + /// + /// Introduced by the 2026-07-28 protocol revision (SEP-2575). For HTTP transports, the value MUST + /// match the MCP-Protocol-Version header. Servers reject a header/body mismatch with + /// . + /// + public const string ProtocolVersion = "io.modelcontextprotocol/protocolVersion"; + + /// + /// The metadata key used to identify the client software in a request's _meta field. + /// + /// + /// Introduced by the 2026-07-28 protocol revision (SEP-2575). Carries an + /// describing the client; replaces the clientInfo previously sent only with initialize. + /// + public const string ClientInfo = "io.modelcontextprotocol/clientInfo"; + + /// + /// The metadata key used to identify the server software in a response's _meta field. + /// + /// + /// Introduced by the 2026-07-28 protocol revision. Servers SHOULD identify themselves by + /// carrying an under this key in every result's + /// _meta. + /// + public const string ServerInfo = "io.modelcontextprotocol/serverInfo"; + + /// + /// The metadata key used to declare client capabilities in a request's _meta field. + /// + /// + /// Introduced by the 2026-07-28 protocol revision (SEP-2575). Carries a + /// describing what optional features the client supports for this specific request. Servers MUST NOT + /// infer capabilities from previous requests. + /// + public const string ClientCapabilities = "io.modelcontextprotocol/clientCapabilities"; + + /// + /// The metadata key used to specify the desired log level for a request's resulting log notifications. + /// + /// + /// Introduced by the 2026-07-28 protocol revision (SEP-2575). Carries a . + /// Replaces the legacy RPC. When absent, the server + /// MUST NOT send log notifications for the request. + /// + public const string LogLevel = "io.modelcontextprotocol/logLevel"; + + /// + /// The metadata key used to associate a notification with the request ID of an active + /// subscription. + /// + /// + /// Introduced by the 2026-07-28 protocol revision (SEP-2575). Allows clients to demultiplex notifications + /// belonging to different subscriptions on a shared channel (especially STDIO). + /// + public const string SubscriptionId = "io.modelcontextprotocol/subscriptionId"; +} diff --git a/src/ModelContextProtocol.Core/Protocol/MissingRequiredClientCapabilityErrorData.cs b/src/ModelContextProtocol.Core/Protocol/MissingRequiredClientCapabilityErrorData.cs new file mode 100644 index 000000000..8e5991f26 --- /dev/null +++ b/src/ModelContextProtocol.Core/Protocol/MissingRequiredClientCapabilityErrorData.cs @@ -0,0 +1,21 @@ +using System.Text.Json.Serialization; + +namespace ModelContextProtocol.Protocol; + +/// +/// Represents the payload for the JSON-RPC error. +/// +/// +/// Introduced by the 2026-07-28 protocol revision (SEP-2575). When a server cannot fulfill a request because +/// the client did not declare a required capability in its per-request +/// _meta/io.modelcontextprotocol/clientCapabilities field, it MUST return this error so clients +/// know which capabilities to advertise on a retry. +/// +public sealed class MissingRequiredClientCapabilityErrorData +{ + /// + /// Gets or sets the client capabilities the server requires to process the request. + /// + [JsonPropertyName("requiredCapabilities")] + public required ClientCapabilities RequiredCapabilities { get; set; } +} diff --git a/src/ModelContextProtocol.Core/Protocol/ModelHint.cs b/src/ModelContextProtocol.Core/Protocol/ModelHint.cs index 37e1001a3..9be4c755f 100644 --- a/src/ModelContextProtocol.Core/Protocol/ModelHint.cs +++ b/src/ModelContextProtocol.Core/Protocol/ModelHint.cs @@ -14,6 +14,9 @@ namespace ModelContextProtocol.Protocol; /// See the schema for details. /// /// +// Sampling support type: only used inside ModelPreferences to hint a model for sampling (createMessage) +// requests, so it is deprecated together with sampling per SEP-2577. +[Obsolete(Obsoletions.DeprecatedSampling_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public sealed class ModelHint { /// diff --git a/src/ModelContextProtocol.Core/Protocol/ModelPreferences.cs b/src/ModelContextProtocol.Core/Protocol/ModelPreferences.cs index 5c7a50acc..f20b33956 100644 --- a/src/ModelContextProtocol.Core/Protocol/ModelPreferences.cs +++ b/src/ModelContextProtocol.Core/Protocol/ModelPreferences.cs @@ -22,6 +22,9 @@ namespace ModelContextProtocol.Protocol; /// See the schema for details. /// /// +// Sampling support type: only used to express model selection preferences on sampling (createMessage) +// requests, so it is deprecated together with sampling per SEP-2577. +[Obsolete(Obsoletions.DeprecatedSampling_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public sealed class ModelPreferences { /// diff --git a/src/ModelContextProtocol.Core/Protocol/NotificationMethods.cs b/src/ModelContextProtocol.Core/Protocol/NotificationMethods.cs index 949361650..7911d9e33 100644 --- a/src/ModelContextProtocol.Core/Protocol/NotificationMethods.cs +++ b/src/ModelContextProtocol.Core/Protocol/NotificationMethods.cs @@ -63,6 +63,7 @@ public static class NotificationMethods /// method to get the updated list of roots from the client. /// /// + [Obsolete(Obsoletions.DeprecatedRoots_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public const string RootsListChangedNotification = "notifications/roots/list_changed"; /// @@ -80,6 +81,7 @@ public static class NotificationMethods /// the server can determine which messages to send based on its own configuration. /// /// + [Obsolete(Obsoletions.DeprecatedLogging_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public const string LoggingMessageNotification = "notifications/message"; /// @@ -143,39 +145,12 @@ public static class NotificationMethods public const string CancelledNotification = "notifications/cancelled"; /// - /// The name of the notification sent when a task status changes. + /// The name of the notification sent first on a + /// response stream to indicate which notification types the server agreed to deliver. /// /// - /// - /// When a task status changes, receivers may send this notification to inform the requestor - /// of the change. This notification includes the full task state. - /// - /// - /// Requestors must not rely on receiving this notification, as it is optional. Receivers - /// are not required to send status notifications and may choose to only send them for - /// certain status transitions. Requestors should continue to poll via tasks/get to ensure - /// they receive status updates. - /// - /// - public const string TaskStatusNotification = "notifications/tasks/status"; - - /// - /// The metadata key used to associate requests, responses, and notifications with a task. - /// - /// - /// - /// This constant defines the key "io.modelcontextprotocol/related-task" used in the - /// _meta field to associate messages with their originating task across the entire - /// request lifecycle. - /// - /// - /// For example, an elicitation that a task-augmented tool call depends on must share the - /// same related task ID with that tool call's task. - /// - /// - /// For tasks/get, tasks/list, and tasks/cancel operations, this - /// metadata should not be included as the taskId is already present in the message structure. - /// + /// Introduced by the 2026-07-28 protocol revision (SEP-2575). The notification's params mirror the shape + /// of the requested notifications and include only the entries the server actually supports. /// - public const string RelatedTaskMetaKey = "io.modelcontextprotocol/related-task"; + public const string SubscriptionsAcknowledgedNotification = "notifications/subscriptions/acknowledged"; } diff --git a/src/ModelContextProtocol.Core/Protocol/NotificationParams.cs b/src/ModelContextProtocol.Core/Protocol/NotificationParams.cs index 54432a4c2..b13a746cd 100644 --- a/src/ModelContextProtocol.Core/Protocol/NotificationParams.cs +++ b/src/ModelContextProtocol.Core/Protocol/NotificationParams.cs @@ -8,8 +8,8 @@ namespace ModelContextProtocol.Protocol; /// public abstract class NotificationParams { - /// Prevent external derivations. - private protected NotificationParams() + /// Initializes the base notification parameter type. + protected NotificationParams() { } diff --git a/src/ModelContextProtocol.Core/Protocol/ReadResourceResult.cs b/src/ModelContextProtocol.Core/Protocol/ReadResourceResult.cs index 084322fde..53e138806 100644 --- a/src/ModelContextProtocol.Core/Protocol/ReadResourceResult.cs +++ b/src/ModelContextProtocol.Core/Protocol/ReadResourceResult.cs @@ -8,7 +8,7 @@ namespace ModelContextProtocol.Protocol; /// /// See the schema for details. /// -public sealed class ReadResourceResult : Result +public sealed class ReadResourceResult : Result, ICacheableResult { /// /// Gets or sets a list of objects that this resource contains. @@ -20,4 +20,14 @@ public sealed class ReadResourceResult : Result /// [JsonPropertyName("contents")] public IList Contents { get; set; } = []; + + /// + [JsonPropertyName("ttlMs")] + [JsonConverter(typeof(TimeSpanMillisecondsConverter))] + public TimeSpan? TimeToLive { get; set; } + + /// + [JsonPropertyName("cacheScope")] + [JsonConverter(typeof(CacheScopeConverter))] + public CacheScope? CacheScope { get; set; } } diff --git a/src/ModelContextProtocol.Core/Protocol/RequestId.cs b/src/ModelContextProtocol.Core/Protocol/RequestId.cs index 47a6fde61..692d9b7b9 100644 --- a/src/ModelContextProtocol.Core/Protocol/RequestId.cs +++ b/src/ModelContextProtocol.Core/Protocol/RequestId.cs @@ -66,7 +66,8 @@ public override RequestId Read(ref Utf8JsonReader reader, Type typeToConvert, Js { JsonTokenType.String => new(reader.GetString()!), JsonTokenType.Number => new(reader.GetInt64()), - _ => throw new JsonException("requestId must be a string or an integer"), + JsonTokenType.Null => default, + _ => throw new JsonException("requestId must be a string, integer, or null"), }; } @@ -86,7 +87,11 @@ public override void Write(Utf8JsonWriter writer, RequestId value, JsonSerialize return; case null: - writer.WriteStringValue(string.Empty); + // A null Id represents a JSON-RPC error response whose request id could not be + // determined (JSON-RPC 2.0 §5; the MCP base protocol permits an error response to a + // malformed request to carry a null id). Emit JSON null — not "" — so the wire form + // is spec-conformant and round-trips losslessly with the Null-accepting Read above. + writer.WriteNullValue(); return; } } diff --git a/src/ModelContextProtocol.Core/Protocol/RequestMethods.cs b/src/ModelContextProtocol.Core/Protocol/RequestMethods.cs index e0118fa57..f0300a564 100644 --- a/src/ModelContextProtocol.Core/Protocol/RequestMethods.cs +++ b/src/ModelContextProtocol.Core/Protocol/RequestMethods.cs @@ -55,6 +55,7 @@ public static class RequestMethods /// /// The name of the request method sent from the server to request a list of the client's roots. /// + [Obsolete(Obsoletions.DeprecatedRoots_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public const string RootsList = "roots/list"; /// @@ -71,6 +72,7 @@ public static class RequestMethods /// send log messages with severity at or above the specified level to the client as /// notifications. /// + [Obsolete(Obsoletions.DeprecatedLogging_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public const string LoggingSetLevel = "logging/setLevel"; /// @@ -91,6 +93,7 @@ public static class RequestMethods /// based on provided messages. It is part of the sampling capability in the Model Context Protocol and enables servers to access /// client-side AI models without needing direct API access to those models. /// + [Obsolete(Obsoletions.DeprecatedSampling_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public const string SamplingCreateMessage = "sampling/createMessage"; /// @@ -123,30 +126,40 @@ public static class RequestMethods public const string Initialize = "initialize"; /// - /// The name of the request method to retrieve task status. + /// The name of the request method sent from the client to discover the server's protocol versions, + /// capabilities, and metadata. /// /// - /// Requestors poll for task completion by sending tasks/get requests. They should respect - /// the pollInterval provided in responses when determining polling frequency. + /// + /// This RPC is introduced in the 2026-07-28 protocol revision (SEP-2575) as the canonical way for a client + /// to learn what a server supports without performing the initialize handshake. + /// + /// + /// The server's response includes its supported protocol versions, capabilities, implementation + /// information, and optional usage instructions. + /// + /// + /// Servers SHOULD implement this method. Initialize-handshake clients MAY ignore it. Clients on the + /// 2026-07-28 revision typically call this once during connection establishment. + /// /// - public const string TasksGet = "tasks/get"; + public const string ServerDiscover = "server/discover"; /// - /// The name of the request method to retrieve the result of a completed task. + /// The name of the request method sent from the client to open a long-lived subscription for + /// receiving server-to-client notifications outside of a specific request's response stream. /// /// - /// This request blocks until the task reaches a terminal status (completed, failed, or cancelled). - /// The result structure matches the original request type (e.g., CallToolResult for tools/call). + /// + /// This RPC is introduced in the 2026-07-28 protocol revision (SEP-2575) and replaces the unsolicited + /// HTTP GET endpoint and the initialize-handshake / + /// request methods. + /// + /// + /// The request opens a response stream on which the server first sends a + /// describing the granted + /// notifications, and then streams matching notifications until the subscription is cancelled. + /// /// - public const string TasksResult = "tasks/result"; - - /// - /// The name of the request method to retrieve a list of tasks with pagination support. - /// - public const string TasksList = "tasks/list"; - - /// - /// The name of the request method to explicitly cancel a task. - /// - public const string TasksCancel = "tasks/cancel"; + public const string SubscriptionsListen = "subscriptions/listen"; } \ No newline at end of file diff --git a/src/ModelContextProtocol.Core/Protocol/RequestParams.cs b/src/ModelContextProtocol.Core/Protocol/RequestParams.cs index 0a0586a71..04c3d82ef 100644 --- a/src/ModelContextProtocol.Core/Protocol/RequestParams.cs +++ b/src/ModelContextProtocol.Core/Protocol/RequestParams.cs @@ -11,8 +11,8 @@ namespace ModelContextProtocol.Protocol; /// public abstract class RequestParams { - /// Prevent external derivations. - private protected RequestParams() + /// Initializes the base request parameter type. + protected RequestParams() { } @@ -25,6 +25,32 @@ private protected RequestParams() [JsonPropertyName("_meta")] public JsonObject? Meta { get; set; } + /// + /// Gets or sets the responses to server-initiated input requests from a previous . + /// + /// + /// + /// This property is populated when retrying a request after receiving an . + /// Each key corresponds to a key from the map, and + /// the value is the client's response to that input request. + /// + /// + [JsonPropertyName("inputResponses")] + public IDictionary? InputResponses { get; set; } + + /// + /// Gets or sets opaque request state echoed back from a previous . + /// + /// + /// + /// This property is populated when retrying a request after receiving an + /// that included a value. The client must echo back the + /// exact value without modification. + /// + /// + [JsonPropertyName("requestState")] + public string? RequestState { get; set; } + /// /// Gets the opaque token that will be attached to any subsequent progress notifications. /// diff --git a/src/ModelContextProtocol.Core/Protocol/Result.cs b/src/ModelContextProtocol.Core/Protocol/Result.cs index 58b076ddb..e64be9728 100644 --- a/src/ModelContextProtocol.Core/Protocol/Result.cs +++ b/src/ModelContextProtocol.Core/Protocol/Result.cs @@ -8,8 +8,8 @@ namespace ModelContextProtocol.Protocol; /// public abstract class Result { - /// Prevent external derivations. - private protected Result() + /// Initializes the base result type. + protected Result() { } @@ -21,4 +21,18 @@ private protected Result() /// [JsonPropertyName("_meta")] public JsonObject? Meta { get; set; } + + /// + /// Gets or sets the type of the result, which allows the client to determine how to parse the result object. + /// + /// + /// + /// When absent or set to "complete", the result is a normal completed response. + /// Other values discriminate alternate result subtypes so callers can choose the appropriate + /// concrete payload to deserialize. + /// + /// + /// Defaults to , which is equivalent to "complete". + [JsonPropertyName("resultType")] + public string? ResultType { get; set; } } diff --git a/src/ModelContextProtocol.Core/Protocol/ResultOrAlternate.cs b/src/ModelContextProtocol.Core/Protocol/ResultOrAlternate.cs new file mode 100644 index 000000000..8303978fe --- /dev/null +++ b/src/ModelContextProtocol.Core/Protocol/ResultOrAlternate.cs @@ -0,0 +1,95 @@ +using System.Diagnostics.CodeAnalysis; +using System.Text.Json.Serialization.Metadata; + +namespace ModelContextProtocol.Protocol; + +/// +/// Represents the result of a request that may return either the standard result or an alternate +/// subtype for scenarios like asynchronous task execution. +/// +/// The standard result type for the request (e.g., ). +/// +/// +/// Extensions that augment request handling (such as the Tasks extension) use this type to indicate +/// that the server returned an alternate result instead of the normal one. The alternate carries its +/// own so the transport layer can serialize it without compile-time knowledge +/// of the concrete type. +/// +/// +/// Use to determine which variant was returned, then access either +/// for the immediate result or for the alternate. +/// +/// +[Experimental(Experimentals.Extensibility_DiagnosticId, UrlFormat = Experimentals.Extensibility_Url)] +public class ResultOrAlternate where TResult : Result +{ + private readonly TResult? _result; + private readonly Result? _alternate; + private readonly JsonTypeInfo? _alternateTypeInfo; + + /// + /// Initializes a new instance of with an immediate result. + /// + /// The standard result returned by the server. + public ResultOrAlternate(TResult result) + { + Throw.IfNull(result); + _result = result; + } + + /// + /// Initializes a new instance of with an alternate result. + /// + /// The alternate result. + /// The used to serialize the alternate result. + private ResultOrAlternate(Result alternate, JsonTypeInfo alternateTypeInfo) + { + Throw.IfNull(alternate); + Throw.IfNull(alternateTypeInfo); + _alternate = alternate; + _alternateTypeInfo = alternateTypeInfo; + } + + /// + /// Creates a that carries an alternate subtype + /// (for example an InputRequiredResult or a task-creation result) in place of the standard result. + /// + /// The concrete alternate result type. + /// The alternate result to return instead of the standard result. + /// + /// The used to serialize . Requiring the strongly-typed + /// contract keeps the alternate value paired with matching serializer metadata rather than an unrelated type. + /// + /// A that wraps the alternate result. + public static ResultOrAlternate FromAlternate(TAlternate alternate, JsonTypeInfo alternateTypeInfo) + where TAlternate : Result + => new(alternate, alternateTypeInfo); + + /// + /// Gets a value indicating whether the server returned an alternate result instead of the standard result. + /// + public bool IsAlternate => _alternate is not null; + + /// + /// Gets the immediate result, or if the server returned an alternate. + /// + public TResult? Result => _result; + + /// + /// Gets the alternate result, or if the server returned the standard result. + /// + public Result? Alternate => _alternate; + + /// + /// Gets the for serializing the alternate result, or + /// if the server returned the standard result. + /// + public JsonTypeInfo? AlternateTypeInfo => _alternateTypeInfo; + + /// + /// Implicitly converts a to a + /// wrapping the immediate result. + /// + /// The result to wrap. + public static implicit operator ResultOrAlternate(TResult result) => new(result); +} diff --git a/src/ModelContextProtocol.Core/Protocol/Root.cs b/src/ModelContextProtocol.Core/Protocol/Root.cs index 622dbddb9..debeefd57 100644 --- a/src/ModelContextProtocol.Core/Protocol/Root.cs +++ b/src/ModelContextProtocol.Core/Protocol/Root.cs @@ -14,6 +14,7 @@ namespace ModelContextProtocol.Protocol; /// guidance rather than an access-control mechanism. Each root has a URI that uniquely identifies /// it and optional metadata like a human-readable name. /// +[Obsolete(Obsoletions.DeprecatedRoots_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public sealed class Root { /// diff --git a/src/ModelContextProtocol.Core/Protocol/RootsCapability.cs b/src/ModelContextProtocol.Core/Protocol/RootsCapability.cs index 0b2f9e762..eebcb741d 100644 --- a/src/ModelContextProtocol.Core/Protocol/RootsCapability.cs +++ b/src/ModelContextProtocol.Core/Protocol/RootsCapability.cs @@ -21,6 +21,7 @@ namespace ModelContextProtocol.Protocol; /// See the schema for details. /// /// +[Obsolete(Obsoletions.DeprecatedRoots_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public sealed class RootsCapability { /// diff --git a/src/ModelContextProtocol.Core/Protocol/RootsListChangedNotificationParams.cs b/src/ModelContextProtocol.Core/Protocol/RootsListChangedNotificationParams.cs index 62312ab32..b4fe33b5f 100644 --- a/src/ModelContextProtocol.Core/Protocol/RootsListChangedNotificationParams.cs +++ b/src/ModelContextProtocol.Core/Protocol/RootsListChangedNotificationParams.cs @@ -12,4 +12,5 @@ namespace ModelContextProtocol.Protocol; /// See the schema for details. /// /// +[Obsolete(Obsoletions.DeprecatedRoots_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public sealed class RootsListChangedNotificationParams : NotificationParams; diff --git a/src/ModelContextProtocol.Core/Protocol/SamplingCapability.cs b/src/ModelContextProtocol.Core/Protocol/SamplingCapability.cs index cb530e795..7a4d015de 100644 --- a/src/ModelContextProtocol.Core/Protocol/SamplingCapability.cs +++ b/src/ModelContextProtocol.Core/Protocol/SamplingCapability.cs @@ -17,6 +17,7 @@ namespace ModelContextProtocol.Protocol; /// using an AI model. The client must set a to process these requests. /// /// +[Obsolete(Obsoletions.DeprecatedSampling_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public sealed class SamplingCapability { /// diff --git a/src/ModelContextProtocol.Core/Protocol/SamplingContextCapability.cs b/src/ModelContextProtocol.Core/Protocol/SamplingContextCapability.cs index bae960f3a..a26bc5ccc 100644 --- a/src/ModelContextProtocol.Core/Protocol/SamplingContextCapability.cs +++ b/src/ModelContextProtocol.Core/Protocol/SamplingContextCapability.cs @@ -3,4 +3,5 @@ namespace ModelContextProtocol.Protocol; /// /// Represents the sampling context capability. /// +[Obsolete(Obsoletions.DeprecatedSampling_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public sealed class SamplingContextCapability; \ No newline at end of file diff --git a/src/ModelContextProtocol.Core/Protocol/SamplingMessage.cs b/src/ModelContextProtocol.Core/Protocol/SamplingMessage.cs index d929a6877..1e2fa4c10 100644 --- a/src/ModelContextProtocol.Core/Protocol/SamplingMessage.cs +++ b/src/ModelContextProtocol.Core/Protocol/SamplingMessage.cs @@ -28,6 +28,7 @@ namespace ModelContextProtocol.Protocol; /// /// [DebuggerDisplay("{DebuggerDisplay,nq}")] +[Obsolete(Obsoletions.DeprecatedSampling_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public sealed class SamplingMessage { /// diff --git a/src/ModelContextProtocol.Core/Protocol/SamplingToolsCapability.cs b/src/ModelContextProtocol.Core/Protocol/SamplingToolsCapability.cs index f93b79725..276c36089 100644 --- a/src/ModelContextProtocol.Core/Protocol/SamplingToolsCapability.cs +++ b/src/ModelContextProtocol.Core/Protocol/SamplingToolsCapability.cs @@ -3,4 +3,5 @@ namespace ModelContextProtocol.Protocol; /// /// Represents the sampling tools capability. /// +[Obsolete(Obsoletions.DeprecatedSampling_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public sealed class SamplingToolsCapability; \ No newline at end of file diff --git a/src/ModelContextProtocol.Core/Protocol/ServerCapabilities.cs b/src/ModelContextProtocol.Core/Protocol/ServerCapabilities.cs index d4e23a66f..95cfa078d 100644 --- a/src/ModelContextProtocol.Core/Protocol/ServerCapabilities.cs +++ b/src/ModelContextProtocol.Core/Protocol/ServerCapabilities.cs @@ -1,5 +1,3 @@ -using System.ComponentModel; -using System.Diagnostics.CodeAnalysis; using System.Text.Json.Serialization; using ModelContextProtocol.Server; @@ -41,6 +39,7 @@ public sealed class ServerCapabilities /// Gets or sets a server's logging capability for sending log messages to the client. /// [JsonPropertyName("logging")] + [Obsolete(Obsoletions.DeprecatedLogging_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public LoggingCapability? Logging { get; set; } /// @@ -67,32 +66,6 @@ public sealed class ServerCapabilities [JsonPropertyName("completions")] public CompletionsCapability? Completions { get; set; } - /// - /// Gets or sets a server's tasks capability for supporting task-augmented requests. - /// - /// - /// - /// The tasks capability enables clients to augment their requests with tasks for long-running - /// operations. When present, clients can request that certain operations (like tool calls) - /// execute asynchronously, with the ability to poll for status and retrieve results later. - /// - /// - /// See for details on configuring which operations support tasks. - /// - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - [JsonIgnore] - public McpTasksCapability? Tasks - { - get => TasksCore; - set => TasksCore = value; - } - - // See ExperimentalInternalPropertyTests.cs before modifying this property. - [JsonInclude] - [JsonPropertyName("tasks")] - internal McpTasksCapability? TasksCore { get; set; } - /// /// Gets or sets optional MCP extensions that the server supports. /// @@ -107,16 +80,6 @@ public McpTasksCapability? Tasks /// interoperability. Servers advertise extension support via this field during the initialization handshake. /// /// - [Experimental(Experimentals.Extensions_DiagnosticId, UrlFormat = Experimentals.Extensions_Url)] - [JsonIgnore] - public IDictionary? Extensions - { - get => ExtensionsCore; - set => ExtensionsCore = value; - } - - // See ExperimentalInternalPropertyTests.cs before modifying this property. - [JsonInclude] [JsonPropertyName("extensions")] - internal IDictionary? ExtensionsCore { get; set; } + public IDictionary? Extensions { get; set; } } diff --git a/src/ModelContextProtocol.Core/Protocol/SetLevelRequestParams.cs b/src/ModelContextProtocol.Core/Protocol/SetLevelRequestParams.cs index 9441d39ac..2352eb966 100644 --- a/src/ModelContextProtocol.Core/Protocol/SetLevelRequestParams.cs +++ b/src/ModelContextProtocol.Core/Protocol/SetLevelRequestParams.cs @@ -10,6 +10,7 @@ namespace ModelContextProtocol.Protocol; /// This request allows clients to configure the level of logging information they want to receive from the server. /// The server will send notifications for log events at the specified level and all higher (more severe) levels. /// +[Obsolete(Obsoletions.DeprecatedLogging_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public sealed class SetLevelRequestParams : RequestParams { /// diff --git a/src/ModelContextProtocol.Core/Protocol/SubscriptionsAcknowledgedNotificationParams.cs b/src/ModelContextProtocol.Core/Protocol/SubscriptionsAcknowledgedNotificationParams.cs new file mode 100644 index 000000000..577cd3566 --- /dev/null +++ b/src/ModelContextProtocol.Core/Protocol/SubscriptionsAcknowledgedNotificationParams.cs @@ -0,0 +1,27 @@ +using System.Text.Json.Serialization; + +namespace ModelContextProtocol.Protocol; + +/// +/// Represents the parameters sent with a . +/// +/// +/// +/// Introduced by the 2026-07-28 protocol revision (SEP-2575). This notification is the first message on a +/// response stream and informs the client which +/// subset of requested notification types the server has agreed to deliver. +/// +/// +public sealed class SubscriptionsAcknowledgedNotificationParams +{ + /// + /// Gets or sets the notification subscriptions the server has agreed to honor. + /// + /// + /// Only includes notification types the server actually supports. If the client requested an + /// unsupported notification type (e.g., promptsListChanged when the server has no prompts), + /// it is omitted from this set. + /// + [JsonPropertyName("notifications")] + public required SubscriptionsListenNotifications Notifications { get; set; } +} diff --git a/src/ModelContextProtocol.Core/Protocol/SubscriptionsListenRequestParams.cs b/src/ModelContextProtocol.Core/Protocol/SubscriptionsListenRequestParams.cs new file mode 100644 index 000000000..ac6c38c5b --- /dev/null +++ b/src/ModelContextProtocol.Core/Protocol/SubscriptionsListenRequestParams.cs @@ -0,0 +1,71 @@ +using System.Text.Json.Serialization; + +namespace ModelContextProtocol.Protocol; + +/// +/// Represents the parameters used with a request. +/// +/// +/// +/// Introduced by the 2026-07-28 protocol revision (SEP-2575). The client uses this request to open a +/// long-lived channel for receiving notifications outside the context of a specific request. +/// +/// +/// Per-request metadata (protocol version, client info, client capabilities, optional log level) +/// flows through the inherited property under the +/// io.modelcontextprotocol/* keys. +/// +/// +public sealed class SubscriptionsListenRequestParams : RequestParams +{ + /// + /// Gets or sets the notifications the client wants to receive on this subscription stream. + /// + /// + /// Each notification type is opt-in; the server MUST NOT send notification types the client + /// has not explicitly requested here. The server's + /// reports the subset + /// of requested notifications the server actually supports. + /// + [JsonPropertyName("notifications")] + public required SubscriptionsListenNotifications Notifications { get; set; } +} + +/// +/// Describes the set of notification types a client wants to receive (or that a server has agreed +/// to deliver) for a subscription. +/// +public sealed class SubscriptionsListenNotifications +{ + /// + /// Gets or sets a value indicating whether to receive + /// notifications. + /// + [JsonPropertyName("toolsListChanged")] + public bool? ToolsListChanged { get; set; } + + /// + /// Gets or sets a value indicating whether to receive + /// notifications. + /// + [JsonPropertyName("promptsListChanged")] + public bool? PromptsListChanged { get; set; } + + /// + /// Gets or sets a value indicating whether to receive + /// notifications. + /// + [JsonPropertyName("resourcesListChanged")] + public bool? ResourcesListChanged { get; set; } + + /// + /// Gets or sets the list of resource URIs to subscribe to for + /// notifications. + /// + /// + /// Replaces the legacy / + /// RPCs from prior protocol revisions. + /// + [JsonPropertyName("resourceSubscriptions")] + public IList? ResourceSubscriptions { get; set; } +} diff --git a/src/ModelContextProtocol.Core/Protocol/TimeSpanMillisecondsConverter.cs b/src/ModelContextProtocol.Core/Protocol/TimeSpanMillisecondsConverter.cs index e789db186..18386d326 100644 --- a/src/ModelContextProtocol.Core/Protocol/TimeSpanMillisecondsConverter.cs +++ b/src/ModelContextProtocol.Core/Protocol/TimeSpanMillisecondsConverter.cs @@ -10,7 +10,10 @@ namespace ModelContextProtocol.Protocol; /// /// This converter serializes TimeSpan values as the total number of milliseconds (as an integer), /// and deserializes integer millisecond values back to TimeSpan. System.Text.Json automatically -/// handles nullable TimeSpan properties using this converter. +/// handles nullable TimeSpan properties using this converter. Millisecond values that fall outside +/// the range representable by are clamped to +/// / rather than throwing, so an +/// oversized or malformed hint can never break deserialization of the enclosing result. /// [EditorBrowsable(EditorBrowsableState.Never)] public sealed class TimeSpanMillisecondsConverter : JsonConverter @@ -22,17 +25,93 @@ public override TimeSpan Read(ref Utf8JsonReader reader, Type typeToConvert, Jso { if (reader.TryGetInt64(out long milliseconds)) { - return TimeSpan.FromMilliseconds(milliseconds); + return FromMillisecondsClamped(milliseconds); } - // For non-integer values, convert from fractional milliseconds - double fractionalMilliseconds = reader.GetDouble(); - return TimeSpan.FromTicks((long)(fractionalMilliseconds * TimeSpan.TicksPerMillisecond)); + // Non-integer value: fractional, or a magnitude too large to represent. Use the non-throwing + // TryGetDouble so an out-of-range exponent never breaks deserialization. Note that different + // runtimes disagree on out-of-range doubles: in-box .NET returns +/-Infinity, whereas .NET + // Framework's parser reports failure. Handle both so behavior is identical everywhere. + if (reader.TryGetDouble(out double value)) + { + if (double.IsPositiveInfinity(value)) + { + return TimeSpan.MaxValue; + } + + if (double.IsNegativeInfinity(value)) + { + return TimeSpan.MinValue; + } + + return FromTicksClamped(value * TimeSpan.TicksPerMillisecond); + } + + // The runtime could not represent the number as a double at all (e.g. .NET Framework on an + // overflowing exponent). Clamp by the sign of the raw token. + return IsNegativeNumberToken(ref reader) ? TimeSpan.MinValue : TimeSpan.MaxValue; } throw new JsonException($"Unable to convert {reader.TokenType} to TimeSpan."); } + private static bool IsNegativeNumberToken(ref Utf8JsonReader reader) + { + ReadOnlySpan token = reader.HasValueSequence ? reader.ValueSequence.First.Span : reader.ValueSpan; + return !token.IsEmpty && token[0] == (byte)'-'; + } + + // Largest whole-millisecond count representable as a TimeSpan (TimeSpan.MaxValue.Ticks / TicksPerMillisecond). + private const long MaxWholeMilliseconds = long.MaxValue / TimeSpan.TicksPerMillisecond; + + // Converts an integer millisecond count to a TimeSpan, clamping out-of-range values to + // TimeSpan.MinValue/MaxValue instead of throwing. A malformed or oversized hint (for example a + // hostile or buggy server returning an enormous ttlMs) must never break deserialization of the + // whole result; per SEP-2549 clients should handle unexpected TTL values gracefully. + private static TimeSpan FromMillisecondsClamped(long milliseconds) + { + if (milliseconds > MaxWholeMilliseconds) + { + return TimeSpan.MaxValue; + } + + if (milliseconds < -MaxWholeMilliseconds) + { + return TimeSpan.MinValue; + } + + return TimeSpan.FromTicks(milliseconds * TimeSpan.TicksPerMillisecond); + } + + // Converts a (possibly fractional or out-of-range) tick count to a TimeSpan, clamping instead of + // throwing. The caller passes a value already scaled into tick-space (milliseconds * TicksPerMillisecond) + // because TimeSpan is backed by a long tick count, so comparing against long.MaxValue/MinValue is the + // exact test for whether the final (long) cast would overflow. The comparisons MUST run before that cast: + // double arithmetic saturates to +/-Infinity on overflow rather than throwing, and both infinities fall + // into the clamp branches here (+Infinity >= long.MaxValue, -Infinity <= long.MinValue); if Infinity + // instead reached "(long)ticks" the unchecked conversion would silently yield long.MinValue. NaN is not + // reachable from valid JSON (the only multiplicand is a non-zero constant) but is mapped to zero + // defensively so a non-numeric hint can never break deserialization. + private static TimeSpan FromTicksClamped(double ticks) + { + if (double.IsNaN(ticks)) + { + return TimeSpan.Zero; + } + + if (ticks >= long.MaxValue) + { + return TimeSpan.MaxValue; + } + + if (ticks <= long.MinValue) + { + return TimeSpan.MinValue; + } + + return TimeSpan.FromTicks((long)ticks); + } + /// public override void Write(Utf8JsonWriter writer, TimeSpan value, JsonSerializerOptions options) { diff --git a/src/ModelContextProtocol.Core/Protocol/Tool.cs b/src/ModelContextProtocol.Core/Protocol/Tool.cs index 8abbfd88c..274d53be3 100644 --- a/src/ModelContextProtocol.Core/Protocol/Tool.cs +++ b/src/ModelContextProtocol.Core/Protocol/Tool.cs @@ -64,6 +64,7 @@ public sealed class Tool : IBaseMetadata /// /// [JsonPropertyName("inputSchema")] + [JsonRequired] public JsonElement InputSchema { get => field; @@ -80,17 +81,24 @@ public JsonElement InputSchema } = McpJsonUtilities.DefaultMcpToolSchema; /// - /// Gets or sets a JSON Schema object defining the expected structured outputs for the tool. + /// Gets or sets a JSON Schema document describing the shape of the tool's structured output. /// - /// The value is not a valid MCP tool JSON schema. + /// + /// The value is not a valid JSON Schema 2020-12 document — i.e., not a JSON object or a + /// JSON boolean. + /// /// /// - /// The schema must be a valid JSON Schema object with the "type" property set to "object". - /// This is enforced by validation in the setter which will throw an - /// if an invalid schema is provided. + /// Per SEP-2106 ("Allow valid JSON Schemas in outputSchema"), the schema may describe + /// any JSON value — object, array, string, number, boolean, or — to + /// support tools whose structured output is not an object. The setter only checks that the + /// supplied value is a structurally valid JSON Schema 2020-12 document (a JSON object, or + /// the boolean schemas true/false per §4.3); deeper keyword-level validation + /// is intentionally not performed. /// /// - /// The schema should describe the shape of the data as returned in . + /// The schema describes the shape of the value placed in . + /// Unlike , the top-level type is not required to be "object". /// /// [JsonPropertyName("outputSchema")] @@ -99,9 +107,9 @@ public JsonElement? OutputSchema get => field; set { - if (value is not null && !McpJsonUtilities.IsValidMcpToolSchema(value.Value)) + if (value is not null && !McpJsonUtilities.IsValidToolOutputSchema(value.Value)) { - throw new ArgumentException("The specified document is not a valid MCP tool output JSON schema.", nameof(OutputSchema)); + throw new ArgumentException("The specified document is not a valid JSON Schema 2020-12 document (must be a JSON object or a JSON boolean).", nameof(OutputSchema)); } field = value; @@ -119,26 +127,6 @@ public JsonElement? OutputSchema [JsonPropertyName("annotations")] public ToolAnnotations? Annotations { get; set; } - /// - /// Gets or sets execution-related metadata for this tool. - /// - /// - /// This property provides hints about how the tool should be executed, particularly - /// regarding task augmentation support. See for details. - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - [JsonIgnore] - public ToolExecution? Execution - { - get => ExecutionCore; - set => ExecutionCore = value; - } - - // See ExperimentalInternalPropertyTests.cs before modifying this property. - [JsonInclude] - [JsonPropertyName("execution")] - internal ToolExecution? ExecutionCore { get; set; } - /// /// Gets or sets an optional list of icons for this tool. /// diff --git a/src/ModelContextProtocol.Core/Protocol/ToolChoice.cs b/src/ModelContextProtocol.Core/Protocol/ToolChoice.cs index ebb80552f..903e978c6 100644 --- a/src/ModelContextProtocol.Core/Protocol/ToolChoice.cs +++ b/src/ModelContextProtocol.Core/Protocol/ToolChoice.cs @@ -5,6 +5,9 @@ namespace ModelContextProtocol.Protocol; /// /// Controls tool selection behavior for sampling requests. /// +// Sampling support type: only used to configure tool selection on sampling (createMessage) requests, +// so it is deprecated together with sampling per SEP-2577. +[Obsolete(Obsoletions.DeprecatedSampling_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public sealed class ToolChoice { /// diff --git a/src/ModelContextProtocol.Core/Protocol/ToolExecution.cs b/src/ModelContextProtocol.Core/Protocol/ToolExecution.cs deleted file mode 100644 index 174298471..000000000 --- a/src/ModelContextProtocol.Core/Protocol/ToolExecution.cs +++ /dev/null @@ -1,85 +0,0 @@ -using System.Diagnostics.CodeAnalysis; -using System.Text.Json.Serialization; - -namespace ModelContextProtocol.Protocol; - -/// -/// Represents execution-related metadata for a tool. -/// -/// -/// This type provides hints about how a tool should be executed, particularly -/// regarding task augmentation support. -/// -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -public sealed class ToolExecution -{ - /// - /// Gets or sets the level of task augmentation support for this tool. - /// - /// - /// - /// This property declares whether a tool supports task-augmented execution: - /// - /// : Clients must not attempt to invoke - /// the tool as a task. This is the default behavior. - /// : Clients may invoke the tool as a task - /// or as a normal request. - /// : Clients must invoke the tool as a task. - /// - /// - /// - /// - /// This is a fine-grained layer in addition to server capabilities. Even if a server's capabilities - /// include tasks.requests.tools.call, this property controls whether each specific tool supports tasks. - /// - /// - [JsonPropertyName("taskSupport")] - public ToolTaskSupport? TaskSupport { get; set; } -} - -/// -/// Represents the level of task augmentation support for a tool. -/// -/// -/// -/// This enum defines how a tool interacts with the task augmentation system: -/// -/// : Task augmentation is not allowed (default) -/// : Task augmentation is supported but not required -/// : Task augmentation is mandatory -/// -/// -/// -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -[JsonConverter(typeof(JsonStringEnumConverter))] -public enum ToolTaskSupport -{ - /// - /// Clients must not attempt to invoke the tool as a task. - /// - /// - /// This is the default behavior. Servers should return a -32601 (Method not found) error - /// if a client attempts to invoke the tool as a task when this is set. - /// - [JsonStringEnumMemberName("forbidden")] - Forbidden, - - /// - /// Clients may invoke the tool as a task or as a normal request. - /// - /// - /// When this is set, clients can choose whether to use task augmentation based on their needs. - /// - [JsonStringEnumMemberName("optional")] - Optional, - - /// - /// Clients must invoke the tool as a task. - /// - /// - /// Servers must return a -32601 (Method not found) error if a client does not attempt - /// to invoke the tool as a task when this is set. - /// - [JsonStringEnumMemberName("required")] - Required -} diff --git a/src/ModelContextProtocol.Core/Protocol/UnsupportedProtocolVersionErrorData.cs b/src/ModelContextProtocol.Core/Protocol/UnsupportedProtocolVersionErrorData.cs new file mode 100644 index 000000000..ab684e6cf --- /dev/null +++ b/src/ModelContextProtocol.Core/Protocol/UnsupportedProtocolVersionErrorData.cs @@ -0,0 +1,26 @@ +using System.Text.Json.Serialization; + +namespace ModelContextProtocol.Protocol; + +/// +/// Represents the payload for the JSON-RPC error. +/// +/// +/// Introduced by the 2026-07-28 protocol revision (SEP-2575). When a server receives a request whose +/// declared protocol version it does not implement, it MUST return this error so clients can +/// fall back to a mutually supported version. +/// +public sealed class UnsupportedProtocolVersionErrorData +{ + /// + /// Gets or sets the protocol version strings that the server supports. + /// + [JsonPropertyName("supported")] + public required IList Supported { get; set; } + + /// + /// Gets or sets the protocol version requested by the client. + /// + [JsonPropertyName("requested")] + public required string Requested { get; set; } +} diff --git a/src/ModelContextProtocol.Core/RequestHandlers.cs b/src/ModelContextProtocol.Core/RequestHandlers.cs index 97e8b95df..2a21008f4 100644 --- a/src/ModelContextProtocol.Core/RequestHandlers.cs +++ b/src/ModelContextProtocol.Core/RequestHandlers.cs @@ -45,4 +45,36 @@ public void Set( return JsonSerializer.SerializeToNode(result, responseTypeInfo); }; } + +#pragma warning disable MCPEXP002 // SetWithAlternate consumes the experimental ResultOrAlternate seam + /// + /// Registers a handler that may return either a standard result or an alternate + /// subtype for scenarios like task-augmented execution. + /// + public void SetWithAlternate( + string method, + Func>> handler, + JsonTypeInfo requestTypeInfo, + JsonTypeInfo responseTypeInfo) + where TResult : Result + { + Throw.IfNull(method); + Throw.IfNull(handler); + Throw.IfNull(requestTypeInfo); + Throw.IfNull(responseTypeInfo); + + this[method] = async (request, cancellationToken) => + { + TParams typedRequest = JsonSerializer.Deserialize(request.Params, requestTypeInfo)!; + var augmented = await handler(typedRequest, request, cancellationToken).ConfigureAwait(false); + + if (augmented.IsAlternate) + { + return JsonSerializer.SerializeToNode(augmented.Alternate!, augmented.AlternateTypeInfo!); + } + + return JsonSerializer.SerializeToNode(augmented.Result!, responseTypeInfo); + }; + } +#pragma warning restore MCPEXP002 } diff --git a/src/ModelContextProtocol.Core/Server/AIFunctionMcpServerTool.cs b/src/ModelContextProtocol.Core/Server/AIFunctionMcpServerTool.cs index 700d9d26d..82b6ceb9d 100644 --- a/src/ModelContextProtocol.Core/Server/AIFunctionMcpServerTool.cs +++ b/src/ModelContextProtocol.Core/Server/AIFunctionMcpServerTool.cs @@ -1,4 +1,4 @@ -using Microsoft.Extensions.AI; +using Microsoft.Extensions.AI; using Microsoft.Extensions.DependencyInjection; using ModelContextProtocol.Protocol; using System.ComponentModel; @@ -13,7 +13,6 @@ namespace ModelContextProtocol.Server; /// Provides an that's implemented via an . internal sealed partial class AIFunctionMcpServerTool : McpServerTool { - private readonly bool _structuredOutputRequiresWrapping; private readonly IReadOnlyList _metadata; /// @@ -120,10 +119,16 @@ private static AIFunctionFactoryOptions CreateAIFunctionFactoryOptions( Name = options?.Name ?? function.Name, Description = GetToolDescription(function, options), InputSchema = function.JsonSchema, - OutputSchema = CreateOutputSchema(function, options, out bool structuredOutputRequiresWrapping), + OutputSchema = CreateOutputSchema(function, options), Icons = options?.Icons, }; + // Add x-mcp-header extensions to the input schema based on McpHeaderAttribute on parameters + if (function.UnderlyingMethod is { } method) + { + tool.InputSchema = AddMcpHeaderExtensions(tool.InputSchema, method); + } + if (options is not null) { if (options.Title is not null || @@ -148,26 +153,9 @@ options.OpenWorld is not null || tool.Meta = function.UnderlyingMethod is not null ? CreateMetaFromAttributes(function.UnderlyingMethod, options.Meta) : options.Meta; - - // Apply user-specified Execution settings if provided - if (options.Execution is not null) - { - tool.Execution = options.Execution; - } } - // Auto-detect async methods and mark with taskSupport = "optional" unless explicitly configured. - // This enables implicit task support for async tools: clients can choose to invoke them - // synchronously (wait for completion) or as a task (receive taskId, poll for result). - if (function.UnderlyingMethod is not null && - IsAsyncMethod(function.UnderlyingMethod) && - tool.Execution?.TaskSupport is null) - { - tool.Execution ??= new ToolExecution(); - tool.Execution.TaskSupport = ToolTaskSupport.Optional; - } - - return new AIFunctionMcpServerTool(function, tool, options?.Services, structuredOutputRequiresWrapping, options?.Metadata ?? []); + return new AIFunctionMcpServerTool(function, tool, options?.Services, options?.Metadata ?? []); } private static McpServerToolCreateOptions DeriveOptions(MethodInfo method, McpServerToolCreateOptions? options) @@ -212,12 +200,6 @@ private static McpServerToolCreateOptions DeriveOptions(MethodInfo method, McpSe serializerOptions: newOptions.SerializerOptions ?? McpJsonUtilities.DefaultOptions, inferenceOptions: newOptions.SchemaCreateOptions); } - - if (toolAttr._taskSupport is { } taskSupport) - { - newOptions.Execution ??= new ToolExecution(); - newOptions.Execution.TaskSupport ??= taskSupport; - } } if (method.GetCustomAttribute() is { } descAttr) @@ -235,14 +217,13 @@ private static McpServerToolCreateOptions DeriveOptions(MethodInfo method, McpSe internal AIFunction AIFunction { get; } /// Initializes a new instance of the class. - private AIFunctionMcpServerTool(AIFunction function, Tool tool, IServiceProvider? serviceProvider, bool structuredOutputRequiresWrapping, IReadOnlyList metadata) + private AIFunctionMcpServerTool(AIFunction function, Tool tool, IServiceProvider? serviceProvider, IReadOnlyList metadata) { ValidateToolName(tool.Name); AIFunction = function; ProtocolTool = tool; - _structuredOutputRequiresWrapping = structuredOutputRequiresWrapping; _metadata = metadata; } @@ -252,6 +233,40 @@ private AIFunctionMcpServerTool(AIFunction function, Tool tool, IServiceProvider /// public override IReadOnlyList Metadata => _metadata; + /// + /// Returns a clone whose is rewritten + /// into the wire shape required by clients on protocol versions older than + /// "2026-07-28". Those versions require outputSchema.type == "object"; + /// SEP-2106 (negotiated at "2026-07-28" and later) widens that to any JSON + /// Schema 2020-12 document. To stay compatible, non-object schemas are wrapped in + /// {"type":"object","properties":{"result":<schema>}} and the + /// type:["object","null"] array form is normalized to plain "object" + /// before emission. Returns unchanged when there is no + /// output schema. Callers must gate the call on the negotiated version — this method + /// is unconditional; the gate lives at the emission site. + /// + internal Tool BuildLegacyWireProtocolTool() + { + if (ProtocolTool.OutputSchema is not { } natural) + { + return ProtocolTool; + } + + JsonElement legacyOutputSchema = TransformOutputSchemaForLegacyWire(natural); + + return new Tool + { + Name = ProtocolTool.Name, + Title = ProtocolTool.Title, + Description = ProtocolTool.Description, + InputSchema = ProtocolTool.InputSchema, + OutputSchema = legacyOutputSchema, + Annotations = ProtocolTool.Annotations, + Icons = ProtocolTool.Icons, + Meta = ProtocolTool.Meta, + }; + } + /// public override async ValueTask InvokeAsync( RequestContext request, CancellationToken cancellationToken = default) @@ -273,7 +288,7 @@ public override async ValueTask InvokeAsync( object? result; result = await AIFunction.InvokeAsync(arguments, cancellationToken).ConfigureAwait(false); - JsonElement? structuredContent = CreateStructuredResponse(result); + JsonElement? structuredContent = CreateStructuredResponse(result, request.Server.NegotiatedProtocolVersion); return result switch { AIContent aiContent => new() @@ -344,27 +359,27 @@ internal static string DeriveName(MethodInfo method, JsonNamingPolicy? policy = // Case the name based on the provided naming policy. return (policy ?? JsonNamingPolicy.SnakeCaseLower).ConvertName(name) ?? name; - } - - private static bool IsAsyncMethod(MethodInfo method) - { - Type t = method.ReturnType; - if (t == typeof(Task) || t == typeof(ValueTask)) + static bool IsAsyncMethod(MethodInfo method) { - return true; - } + Type t = method.ReturnType; - if (t.IsGenericType) - { - t = t.GetGenericTypeDefinition(); - if (t == typeof(Task<>) || t == typeof(ValueTask<>) || t == typeof(IAsyncEnumerable<>)) + if (t == typeof(Task) || t == typeof(ValueTask)) { return true; } - } - return false; + if (t.IsGenericType) + { + t = t.GetGenericTypeDefinition(); + if (t == typeof(Task<>) || t == typeof(ValueTask<>) || t == typeof(IAsyncEnumerable<>)) + { + return true; + } + } + + return false; + } } /// Creates metadata from attributes on the specified method and its declaring class, with the MethodInfo as the first item. @@ -485,48 +500,102 @@ schema.ValueKind is not JsonValueKind.Object || return descriptionElement.GetString(); } - private static JsonElement? CreateOutputSchema(AIFunction function, McpServerToolCreateOptions? toolCreateOptions, out bool structuredOutputRequiresWrapping) + private static JsonElement? CreateOutputSchema(AIFunction function, McpServerToolCreateOptions? toolCreateOptions) { - structuredOutputRequiresWrapping = false; - if (toolCreateOptions?.UseStructuredContent is not true) { return null; } + // Per SEP-2106, any valid JSON Schema document is acceptable for outputSchema — + // arrays, primitives, compositions, and nullable types pass through unchanged. // Explicit OutputSchema takes precedence over AIFunction's return schema. - JsonElement outputSchema; + // Back-compat for pre-2026-07-28 clients is applied at the wire emission sites + // (CreateStructuredResponse for tools/call, listToolsHandler for tools/list). if (toolCreateOptions.OutputSchema is { } explicitSchema) { - outputSchema = explicitSchema; + return explicitSchema; } - else if (function.ReturnJsonSchema is { } returnSchema) + + if (function.ReturnJsonSchema is { } returnSchema) { - outputSchema = returnSchema; + return returnSchema; } - else + + return null; + } + + /// + /// Returns iff the structured-content value must be wrapped in + /// the {"result": <value>} envelope on the wire — i.e., the output schema + /// is neither plain object-typed (type:"object") nor the + /// type:["object","null"] array form. Used by + /// to decide whether to apply the envelope when emitting to a client that negotiated a + /// protocol version older than "2026-07-28" (those versions pre-date SEP-2106's + /// allowance of non-object output schemas). The inner type:["object","null"] + /// check is hoisted into a named bool to keep the surrounding control flow free of + /// empty branches. + /// + internal static bool ShouldWrapValueForLegacyWire(JsonElement schema) + { + bool structuredOutputRequiresWrapping = false; + + if (schema.ValueKind is not JsonValueKind.Object || + !schema.TryGetProperty("type", out JsonElement typeProperty) || + typeProperty.ValueKind is not JsonValueKind.String || + typeProperty.GetString() is not "object") { - return null; + JsonNode? schemaNode = JsonSerializer.SerializeToNode(schema, McpJsonUtilities.JsonContext.Default.JsonElement); + + bool isNullableObjectArray = + schemaNode is JsonObject objSchema && + objSchema.TryGetPropertyValue("type", out JsonNode? typeNode) && + typeNode is JsonArray { Count: 2 } typeArray && + typeArray.Any(type => (string?)type is "object") && + typeArray.Any(type => (string?)type is "null"); + + if (!isNullableObjectArray) + { + structuredOutputRequiresWrapping = true; + } } - if (outputSchema.ValueKind is not JsonValueKind.Object || - !outputSchema.TryGetProperty("type", out JsonElement typeProperty) || + return structuredOutputRequiresWrapping; + } + + /// + /// Transforms into the wire shape required by clients + /// on protocol versions older than "2026-07-28": non-object schemas are wrapped + /// in {"type":"object","properties":{"result":<schema>},"required":["result"]}, + /// the type:["object","null"] array form is normalized to plain "object", + /// and plain object-typed schemas pass through unchanged. SEP-2106 clients + /// ("2026-07-28"+) see the natural schema and never need this transform. + /// Dispatches on so the wrap decision lives + /// in one place. + /// + /// The natural JSON Schema 2020-12 document. + internal static JsonElement TransformOutputSchemaForLegacyWire(JsonElement naturalSchema) + { + if (naturalSchema.ValueKind is not JsonValueKind.Object || + !naturalSchema.TryGetProperty("type", out JsonElement typeProperty) || typeProperty.ValueKind is not JsonValueKind.String || typeProperty.GetString() is not "object") { - // If the output schema is not an object, need to modify to be a valid MCP output schema. - JsonNode? schemaNode = JsonSerializer.SerializeToNode(outputSchema, McpJsonUtilities.JsonContext.Default.JsonElement); + JsonNode? schemaNode = JsonSerializer.SerializeToNode(naturalSchema, McpJsonUtilities.JsonContext.Default.JsonElement); if (schemaNode is JsonObject objSchema && objSchema.TryGetPropertyValue("type", out JsonNode? typeNode) && - typeNode is JsonArray { Count: 2 } typeArray && typeArray.Any(type => (string?)type is "object") && typeArray.Any(type => (string?)type is "null")) + typeNode is JsonArray { Count: 2 } typeArray && + typeArray.Any(type => (string?)type is "object") && + typeArray.Any(type => (string?)type is "null")) { - // For schemas that are of type ["object", "null"], replace with just "object" to be conformant. + // type:["object","null"] → normalize to plain "object". No envelope. objSchema["type"] = "object"; } else { - // For anything else, wrap the schema in an envelope with a "result" property. + // Anything else (string, integer, array, boolean schemas, missing type, + // compositions). Wrap in the {"result": } envelope. schemaNode = new JsonObject { ["type"] = "object", @@ -537,16 +606,65 @@ typeProperty.ValueKind is not JsonValueKind.String || ["required"] = new JsonArray { (JsonNode)"result" } }; - structuredOutputRequiresWrapping = true; + // After wrapping, any internal $ref pointers that used absolute JSON Pointer + // paths (e.g., "#/items/..." or "#") are now invalid because the original schema + // has moved under "#/properties/result". Rewrite them to account for the new location. + RewriteRefPointers(schemaNode["properties"]!["result"]); } - outputSchema = JsonSerializer.Deserialize(schemaNode, McpJsonUtilities.JsonContext.Default.JsonElement); + return JsonSerializer.Deserialize(schemaNode, McpJsonUtilities.JsonContext.Default.JsonElement); } - return outputSchema; + return naturalSchema; + } + + /// + /// Recursively rewrites all $ref JSON Pointer values in the given node + /// to account for the schema having been wrapped under properties.result. + /// + /// + /// System.Text.Json's uses absolute + /// JSON Pointer paths (e.g., #/items/properties/foo) to deduplicate types that appear at + /// multiple locations in the schema. When the original schema is moved under + /// #/properties/result by the wrapping logic above, these pointers become unresolvable. + /// This method prepends /properties/result to every $ref that starts with #/, + /// and rewrites bare # (root self-references from recursive types) to #/properties/result, + /// so the pointers remain valid after wrapping. + /// + private static void RewriteRefPointers(JsonNode? node) + { + if (node is JsonObject obj) + { + if (obj.TryGetPropertyValue("$ref", out JsonNode? refNode) && + refNode?.GetValue() is string refValue) + { + if (refValue == "#") + { + obj["$ref"] = "#/properties/result"; + } + else if (refValue.StartsWith("#/", StringComparison.Ordinal)) + { + obj["$ref"] = "#/properties/result" + refValue.Substring(1); + } + } + + // Safe to iterate without snapshot: the $ref assignment above completes before + // this enumerator is created, and recursive calls only mutate descendant objects. + foreach (var property in obj) + { + RewriteRefPointers(property.Value); + } + } + else if (node is JsonArray arr) + { + foreach (var item in arr) + { + RewriteRefPointers(item); + } + } } - private JsonElement? CreateStructuredResponse(object? aiFunctionResult) + private JsonElement? CreateStructuredResponse(object? aiFunctionResult, string? negotiatedProtocolVersion) { if (ProtocolTool.OutputSchema is null) { @@ -562,10 +680,14 @@ typeProperty.ValueKind is not JsonValueKind.String || _ => JsonSerializer.SerializeToElement(aiFunctionResult, AIFunction.JsonSerializerOptions.GetTypeInfo(typeof(object))), }; - if (_structuredOutputRequiresWrapping) + // Pre-SEP-2106 clients expect the {"result": } envelope for non-object + // schemas. SEP-2106 clients see the natural shape. The classification is decided + // fresh per request from the stored natural schema. + if (!McpSessionHandler.SupportsNaturalOutputSchemas(negotiatedProtocolVersion) && + ShouldWrapValueForLegacyWire(ProtocolTool.OutputSchema.Value)) { - JsonNode? resultNode = elementResult is { } je - ? JsonSerializer.SerializeToNode(je, McpJsonUtilities.JsonContext.Default.JsonElement) + JsonNode? resultNode = elementResult is { } v + ? JsonSerializer.SerializeToNode(v, McpJsonUtilities.JsonContext.Default.JsonElement) : null; return JsonSerializer.SerializeToElement(new JsonObject { @@ -600,4 +722,87 @@ private static CallToolResult ConvertAIContentEnumerableToCallToolResult(IEnumer IsError = allErrorContent && hasAny }; } + + /// + /// Post-processes the input schema to add x-mcp-header extensions based on + /// on method parameters. + /// + private static JsonElement AddMcpHeaderExtensions(JsonElement inputSchema, MethodInfo method) + { + // Collect parameters with McpHeaderAttribute + var headerParams = new List<(string ParameterName, string HeaderName, ParameterInfo Parameter)>(); + var headerNamesSet = new HashSet(StringComparer.OrdinalIgnoreCase); + + foreach (var param in method.GetParameters()) + { + var attr = param.GetCustomAttribute(); + if (attr is null) + { + continue; + } + + // Validate primitive type only + var paramType = Nullable.GetUnderlyingType(param.ParameterType) ?? param.ParameterType; + if (!IsPrimitiveHeaderType(paramType)) + { + throw new InvalidOperationException( + $"Parameter '{param.Name}' on method '{method.Name}' has [McpHeader] but is not a supported type. " + + "Only string, integer, and boolean types may be annotated with [McpHeader]."); + } + + // Validate case-insensitive uniqueness + if (!headerNamesSet.Add(attr.Name)) + { + throw new InvalidOperationException( + $"Duplicate x-mcp-header name '{attr.Name}' (case-insensitive) found on method '{method.Name}'. " + + "Header names must be case-insensitively unique within a tool's input schema."); + } + + headerParams.Add((param.Name!, attr.Name, param)); + } + + if (headerParams.Count == 0) + { + return inputSchema; + } + + // Parse the schema to a mutable JsonNode, add extensions, and convert back + var schemaNode = JsonNode.Parse(inputSchema.GetRawText()); + if (schemaNode is not JsonObject schemaObj || + !schemaObj.TryGetPropertyValue("properties", out var propertiesNode) || + propertiesNode is not JsonObject propertiesObj) + { + return inputSchema; + } + + foreach (var (parameterName, headerName, _) in headerParams) + { + if (propertiesObj.TryGetPropertyValue(parameterName, out var propNode) && + propNode is JsonObject propObj) + { + propObj["x-mcp-header"] = headerName; + } + } + + return JsonSerializer.Deserialize(schemaNode, McpJsonUtilities.JsonContext.Default.JsonElement); + } + + private static bool IsPrimitiveHeaderType(Type type) + { + // Per SEP-2243, x-mcp-header may only be applied to integer, string, or boolean parameters, + // and integer values must stay within the JavaScript safe integer range (-2^53+1 to 2^53-1). + // ulong is excluded because its upper range (above long.MaxValue) cannot be represented as a + // signed integer and the bulk of its domain falls outside the safe range. Remaining integer + // types are allowed here; long values are additionally range-checked per value when emitted + // (client) and validated (server). + return type == typeof(string) || + type == typeof(bool) || + type == typeof(byte) || + type == typeof(sbyte) || + type == typeof(short) || + type == typeof(ushort) || + type == typeof(int) || + type == typeof(uint) || + type == typeof(long); + } } \ No newline at end of file diff --git a/src/ModelContextProtocol.Core/Server/ComposedCallToolInvocationState.cs b/src/ModelContextProtocol.Core/Server/ComposedCallToolInvocationState.cs new file mode 100644 index 000000000..c5f9316b1 --- /dev/null +++ b/src/ModelContextProtocol.Core/Server/ComposedCallToolInvocationState.cs @@ -0,0 +1,84 @@ +using ModelContextProtocol.Protocol; + +namespace ModelContextProtocol.Server; + +#pragma warning disable MCPEXP002 +internal sealed class ComposedCallToolInvocationState +{ + private readonly object _sync = new(); + private readonly List _pendingOrdinaryLifecycles = []; + private bool _outerCompleted; + private bool _outerReturnedAlternate; + + public IReadOnlyList RecordOrdinaryResult(CallToolResult result) => + RecordOrdinaryLifecycle(new(result, null, false)); + + public IReadOnlyList RecordOrdinaryException( + Exception exception, + bool cancellationRequested) => + RecordOrdinaryLifecycle(new(null, exception, cancellationRequested)); + + public IReadOnlyList CompleteOuter(ResultOrAlternate result) + { + lock (_sync) + { + if (result.IsAlternate) + { + _outerReturnedAlternate = true; + return DrainPendingLifecycles(); + } + + _outerCompleted = true; + var exceptions = _pendingOrdinaryLifecycles + .Where(lifecycle => lifecycle.Exception is not null) + .ToArray(); + _pendingOrdinaryLifecycles.Clear(); + return exceptions.Length > 0 ? + exceptions : + [new(result.Result!, null, false)]; + } + } + + public IReadOnlyList CompleteOuterException( + Exception exception, + bool cancellationRequested) + { + lock (_sync) + { + _outerCompleted = true; + _pendingOrdinaryLifecycles.Clear(); + return [new(null, exception, cancellationRequested)]; + } + } + + private IReadOnlyList RecordOrdinaryLifecycle(ToolCallLifecycle lifecycle) + { + lock (_sync) + { + if (_outerReturnedAlternate) + { + return [lifecycle]; + } + + if (!_outerCompleted) + { + _pendingOrdinaryLifecycles.Add(lifecycle); + } + + return []; + } + } + + private IReadOnlyList DrainPendingLifecycles() + { + if (_pendingOrdinaryLifecycles.Count == 0) + { + return []; + } + + var lifecycles = _pendingOrdinaryLifecycles.ToArray(); + _pendingOrdinaryLifecycles.Clear(); + return lifecycles; + } +} +#pragma warning restore MCPEXP002 diff --git a/src/ModelContextProtocol.Core/Server/DestinationBoundMcpServer.cs b/src/ModelContextProtocol.Core/Server/DestinationBoundMcpServer.cs index 957f58a51..7aab34826 100644 --- a/src/ModelContextProtocol.Core/Server/DestinationBoundMcpServer.cs +++ b/src/ModelContextProtocol.Core/Server/DestinationBoundMcpServer.cs @@ -1,20 +1,78 @@ -using ModelContextProtocol.Protocol; -using System.Diagnostics; +using ModelContextProtocol.Protocol; +using System.Text.Json; +using System.Text.Json.Nodes; namespace ModelContextProtocol.Server; #pragma warning disable MCPEXP002 -internal sealed class DestinationBoundMcpServer(McpServerImpl server, ITransport? transport) : McpServer +internal sealed class DestinationBoundMcpServer(McpServerImpl server, ITransport? transport, JsonRpcMessageContext? requestContext = null) : McpServer #pragma warning restore MCPEXP002 { + private readonly bool _isJuly2026OrLaterRequest = server.IsJuly2026OrLaterProtocolRequest(requestContext); + private readonly ClientCapabilities? _requestClientCapabilities = requestContext?.ClientCapabilities; + private readonly Implementation? _requestClientInfo = requestContext?.ClientInfo; + public override string? SessionId => transport?.SessionId ?? server.SessionId; public override string? NegotiatedProtocolVersion => server.NegotiatedProtocolVersion; - public override ClientCapabilities? ClientCapabilities => server.ClientCapabilities; - public override Implementation? ClientInfo => server.ClientInfo; public override McpServerOptions ServerOptions => server.ServerOptions; public override IServiceProvider? Services => server.Services; + [Obsolete(Obsoletions.DeprecatedLogging_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public override LoggingLevel? LoggingLevel => server.LoggingLevel; + public override ClientCapabilities? ClientCapabilities + { + get + { + // In stateless transport mode, a single request does not have a persistent bidirectional channel. + // Server-to-client requests (sampling, roots, elicitation) are unsupported in this mode and the + // capability gates rely on a null ClientCapabilities value to report that unsupported-state path. + if (!server.HasStatefulTransport()) + { + return null; + } + + // On protocol revision 2026-07-28+, client capabilities are request-scoped (_meta on each request) + // and must not be inferred from prior requests. Missing per-request capabilities therefore means + // "no declared capabilities for this request", represented by an empty object. A fresh instance is + // returned deliberately: ClientCapabilities is a mutable DTO handed to user handlers, so a shared + // static empty instance could be mutated and leak across requests. + if (_isJuly2026OrLaterRequest) + { + return _requestClientCapabilities ?? new ClientCapabilities(); + } + + // Legacy protocol behavior uses session-scoped capabilities established during initialize (or + // pre-populated migration data), so ignore per-request values and return the server session state. + return server.ClientCapabilities; + } + } + + public override Implementation? ClientInfo + { + get + { + // On protocol revision 2026-07-28+, client info is request-scoped (carried in each request's _meta), + // mirroring how ClientCapabilities is resolved above. Return only this request's declared value and + // do not fall back to shared session state, which under a stateful transport could belong to a + // different concurrent request. + if (_isJuly2026OrLaterRequest) + { + return _requestClientInfo; + } + + // Legacy protocol behavior uses session-scoped client info established during initialize. + return server.ClientInfo; + } + } + + /// + /// Gets or sets the MRTR context for the current request, if any. + /// Set by when an MRTR-aware handler invocation is in progress. + /// + internal MrtrContext? ActiveMrtrContext { get; set; } + + public override bool IsMrtrSupported => server.IsMrtrSupported; + public override ValueTask DisposeAsync() => server.DisposeAsync(); public override IAsyncDisposable RegisterNotificationHandler(string method, Func handler) => server.RegisterNotificationHandler(method, handler); @@ -39,6 +97,16 @@ public override Task SendMessageAsync(JsonRpcMessage message, CancellationToken public override Task SendRequestAsync(JsonRpcRequest request, CancellationToken cancellationToken = default) { + // When an MRTR context is active, intercept server-to-client requests (sampling, elicitation, roots) + // and route them through the MRTR mechanism instead of sending them over the wire. + // Task-augmented requests (SampleAsTaskAsync/ElicitAsTaskAsync) have a "task" property on their params + // and expect a CreateTaskResult response, so they must bypass MRTR and go over the wire. + if (ActiveMrtrContext is { } mrtrContext && + !(request.Params is JsonObject paramsObj && paramsObj.ContainsKey("task"))) + { + return SendRequestViaMrtrAsync(mrtrContext, request, cancellationToken); + } + if (request.Context is not null) { throw new ArgumentException("Only transports can provide a JsonRpcMessageContext."); @@ -51,4 +119,23 @@ public override Task SendRequestAsync(JsonRpcRequest request, C return server.SendRequestAsync(request, cancellationToken); } + + private static async Task SendRequestViaMrtrAsync( + MrtrContext mrtrContext, JsonRpcRequest request, CancellationToken cancellationToken) + { + var inputRequest = new InputRequest + { + Method = request.Method, + Params = request.Params is { } paramsNode + ? JsonSerializer.Deserialize(paramsNode, McpJsonUtilities.JsonContext.Default.JsonElement) + : null, + }; + var inputResponse = await mrtrContext.RequestInputAsync(inputRequest, cancellationToken).ConfigureAwait(false); + + return new JsonRpcResponse + { + Id = request.Id, + Result = JsonSerializer.SerializeToNode(inputResponse.RawValue, McpJsonUtilities.JsonContext.Default.JsonElement), + }; + } } diff --git a/src/ModelContextProtocol.Core/Server/IMcpTaskStore.cs b/src/ModelContextProtocol.Core/Server/IMcpTaskStore.cs deleted file mode 100644 index d322d21ef..000000000 --- a/src/ModelContextProtocol.Core/Server/IMcpTaskStore.cs +++ /dev/null @@ -1,166 +0,0 @@ -using ModelContextProtocol.Protocol; -using System.Diagnostics.CodeAnalysis; -using System.Text.Json; - -namespace ModelContextProtocol; - -/// -/// Provides an interface for pluggable task storage implementations in MCP servers. -/// -/// -/// -/// The task store is responsible for managing the lifecycle of tasks, including creation, -/// status updates, result storage, and retrieval. Implementations must be thread-safe and -/// may support session-based isolation for multi-session scenarios. -/// -/// -/// TTL (Time To Live) Management: Implementations may override the requested TTL value in -/// to enforce resource limits. The actual TTL -/// used is returned in the property. A null TTL indicates -/// unlimited lifetime. Tasks may be deleted after their TTL expires, regardless of status. -/// -/// -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -public interface IMcpTaskStore -{ - /// - /// Creates a new task for tracking an asynchronous operation. - /// - /// Metadata for the task, including requested TTL. - /// The JSON-RPC request ID that initiated this task. - /// The original JSON-RPC request that triggered task creation. - /// Optional session identifier for multi-session isolation. - /// Cancellation token for the operation. - /// - /// A new with a unique task ID, initial status of , - /// and the actual TTL that will be used (which may differ from the requested TTL). - /// - /// - /// Implementations must generate a unique task ID and set the - /// and timestamps. The implementation may override the - /// requested TTL to enforce storage limits. - /// - Task CreateTaskAsync( - McpTaskMetadata taskParams, - RequestId requestId, - JsonRpcRequest request, - string? sessionId = null, - CancellationToken cancellationToken = default); - - /// - /// Retrieves a task by its unique identifier. - /// - /// The unique identifier of the task to retrieve. - /// Optional session identifier for access control. - /// Cancellation token for the operation. - /// - /// The if found and accessible, otherwise . - /// - /// - /// Returns null if the task does not exist or if session-based access control denies access. - /// - Task GetTaskAsync(string taskId, string? sessionId = null, CancellationToken cancellationToken = default); - - /// - /// Stores the final result of a task that has reached a terminal status. - /// - /// The unique identifier of the task. - /// The terminal status: or . - /// The operation result to store as a JSON element. - /// Optional session identifier for access control. - /// Cancellation token for the operation. - /// The updated with the new status and result stored. - /// - /// - /// The must be either or - /// . This method updates the task status and stores - /// the result for later retrieval via . - /// - /// - /// Implementations should throw if called on a task - /// that is already in a terminal state, to prevent result overwrites. - /// - /// - Task StoreTaskResultAsync( - string taskId, - McpTaskStatus status, - JsonElement result, - string? sessionId = null, - CancellationToken cancellationToken = default); - - /// - /// Retrieves the stored result of a completed or failed task. - /// - /// The unique identifier of the task. - /// Optional session identifier for access control. - /// Cancellation token for the operation. - /// The stored operation result as a JSON element. - /// - /// This method should only be called on tasks in terminal states ( - /// or ). The result contains the JSON representation of the - /// original operation result (e.g., for tools/call). - /// - Task GetTaskResultAsync(string taskId, string? sessionId = null, CancellationToken cancellationToken = default); - - /// - /// Updates the status and optional status message of a task. - /// - /// The unique identifier of the task. - /// The new status to set. - /// Optional diagnostic message describing the status change. - /// Optional session identifier for access control. - /// Cancellation token for the operation. - /// The updated with the new status applied. - /// - /// This method updates the task's , , - /// and properties. Common uses include transitioning to - /// , , or updating - /// progress messages while in status. - /// - Task UpdateTaskStatusAsync( - string taskId, - McpTaskStatus status, - string? statusMessage, - string? sessionId = null, - CancellationToken cancellationToken = default); - - /// - /// Lists tasks with pagination support. - /// - /// Optional cursor for pagination, from a previous call's nextCursor value. - /// Optional session identifier for filtering tasks by session. - /// Cancellation token for the operation. - /// A containing the tasks and an optional cursor for the next page. - /// - /// When is provided, implementations should filter to only return - /// tasks associated with that session. The cursor format is implementation-specific. - /// - Task ListTasksAsync( - string? cursor = null, - string? sessionId = null, - CancellationToken cancellationToken = default); - - /// - /// Attempts to cancel a task, transitioning it to status. - /// - /// The unique identifier of the task to cancel. - /// Optional session identifier for access control. - /// Cancellation token for the operation. - /// - /// The updated . If the task is already in a terminal state - /// (, , or - /// ), the task is returned unchanged. - /// - /// - /// - /// This method must be idempotent. If called on a task that is already in a terminal state, - /// it returns the current task without error. This behavior differs from the MCP specification - /// but ensures idempotency and avoids race conditions between cancellation and task completion. - /// - /// - /// For tasks not in a terminal state, the implementation should attempt to stop the underlying - /// operation and transition the task to status before returning. - /// - /// - Task CancelTaskAsync(string taskId, string? sessionId = null, CancellationToken cancellationToken = default); -} diff --git a/src/ModelContextProtocol.Core/Server/ISseEventStreamReader.cs b/src/ModelContextProtocol.Core/Server/ISseEventStreamReader.cs index 01c642355..dc3a7426c 100644 --- a/src/ModelContextProtocol.Core/Server/ISseEventStreamReader.cs +++ b/src/ModelContextProtocol.Core/Server/ISseEventStreamReader.cs @@ -6,6 +6,7 @@ namespace ModelContextProtocol.Server; /// /// Provides read access to an SSE event stream, allowing events to be consumed asynchronously. /// +[Obsolete(Obsoletions.LegacyStatefulHttp_Message, DiagnosticId = Obsoletions.LegacyStatefulHttp_DiagnosticId, UrlFormat = Obsoletions.LegacyStatefulHttp_Url)] public interface ISseEventStreamReader { /// diff --git a/src/ModelContextProtocol.Core/Server/ISseEventStreamStore.cs b/src/ModelContextProtocol.Core/Server/ISseEventStreamStore.cs index 3d9d9b948..20dda4a18 100644 --- a/src/ModelContextProtocol.Core/Server/ISseEventStreamStore.cs +++ b/src/ModelContextProtocol.Core/Server/ISseEventStreamStore.cs @@ -3,6 +3,7 @@ namespace ModelContextProtocol.Server; /// /// Provides storage and retrieval of SSE event streams, enabling resumability and redelivery of events. /// +[Obsolete(Obsoletions.LegacyStatefulHttp_Message, DiagnosticId = Obsoletions.LegacyStatefulHttp_DiagnosticId, UrlFormat = Obsoletions.LegacyStatefulHttp_Url)] public interface ISseEventStreamStore { /// diff --git a/src/ModelContextProtocol.Core/Server/ISseEventStreamWriter.cs b/src/ModelContextProtocol.Core/Server/ISseEventStreamWriter.cs index 43ddb2361..20d9c747c 100644 --- a/src/ModelContextProtocol.Core/Server/ISseEventStreamWriter.cs +++ b/src/ModelContextProtocol.Core/Server/ISseEventStreamWriter.cs @@ -6,6 +6,7 @@ namespace ModelContextProtocol.Server; /// /// Provides write access to an SSE event stream, allowing events to be written and tracked with unique IDs. /// +[Obsolete(Obsoletions.LegacyStatefulHttp_Message, DiagnosticId = Obsoletions.LegacyStatefulHttp_DiagnosticId, UrlFormat = Obsoletions.LegacyStatefulHttp_Url)] public interface ISseEventStreamWriter : IAsyncDisposable { /// diff --git a/src/ModelContextProtocol.Core/Server/InMemoryMcpTaskStore.cs b/src/ModelContextProtocol.Core/Server/InMemoryMcpTaskStore.cs deleted file mode 100644 index b2f9b050d..000000000 --- a/src/ModelContextProtocol.Core/Server/InMemoryMcpTaskStore.cs +++ /dev/null @@ -1,543 +0,0 @@ -using ModelContextProtocol.Protocol; -using System.Collections.Concurrent; -using System.Diagnostics.CodeAnalysis; -using System.Text.Json; - -#if MCP_TEST_TIME_PROVIDER -namespace ModelContextProtocol.Tests.Internal; -#else -namespace ModelContextProtocol; -#endif - -/// -/// Provides an in-memory implementation of for development and testing. -/// -/// -/// -/// This implementation uses thread-safe concurrent collections and is suitable for single-server -/// scenarios and testing. It is not recommended for production multi-server deployments as tasks -/// are stored only in memory and are lost on server restart. -/// -/// -/// Features: -/// -/// Thread-safe operations using -/// Automatic TTL-based cleanup via background task -/// Session-based isolation when sessionId is provided -/// Configurable default TTL and maximum TTL limits -/// -/// -/// -[Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] -public sealed class InMemoryMcpTaskStore : IMcpTaskStore, IDisposable -{ - private readonly ConcurrentDictionary _tasks = new(); - private readonly TimeSpan? _defaultTtl; - private readonly TimeSpan? _maxTtl; - private readonly TimeSpan _pollInterval; -#if MCP_TEST_TIME_PROVIDER - private readonly ITimer? _cleanupTimer; -#else - private readonly Timer? _cleanupTimer; -#endif - private readonly int _pageSize; - private readonly int? _maxTasks; - private readonly int? _maxTasksPerSession; -#if MCP_TEST_TIME_PROVIDER - private readonly TimeProvider _timeProvider; -#endif - - /// - /// Initializes a new instance of the class. - /// - /// - /// Default TTL to use when task creation does not specify a TTL. Null means unlimited. - /// - /// - /// Maximum TTL allowed. If a task requests a longer TTL, it will be capped to this value. - /// Null means no maximum limit. - /// - /// - /// Advertised polling interval for tasks. Default is 1 second. - /// This value is used when creating new tasks to indicate how frequently clients should poll for updates. - /// - /// - /// Interval for running background cleanup of expired tasks. Default is 1 minute. - /// Pass to disable automatic cleanup. - /// - /// - /// Maximum number of tasks to return per page in . Default is 100. - /// - /// - /// Maximum number of tasks allowed in the store globally. Null means unlimited. - /// When the limit is reached, will throw . - /// - /// - /// Maximum number of tasks allowed per session. Null means unlimited. - /// When the limit is reached for a session, will throw . - /// - public InMemoryMcpTaskStore( - TimeSpan? defaultTtl = null, - TimeSpan? maxTtl = null, - TimeSpan? pollInterval = null, - TimeSpan? cleanupInterval = null, - int pageSize = 100, - int? maxTasks = null, - int? maxTasksPerSession = null) - { - if (defaultTtl.HasValue && maxTtl.HasValue && defaultTtl.Value > maxTtl.Value) - { - throw new ArgumentException( - $"Default TTL ({defaultTtl.Value}) cannot exceed maximum TTL ({maxTtl.Value}).", - nameof(defaultTtl)); - } - - pollInterval ??= TimeSpan.FromSeconds(1); - if (pollInterval <= TimeSpan.Zero) - { - throw new ArgumentOutOfRangeException( - nameof(pollInterval), - pollInterval, - "Poll interval must be positive."); - } - - if (pageSize <= 0) - { - throw new ArgumentOutOfRangeException( - nameof(pageSize), - pageSize, - "Page size must be positive."); - } - - if (maxTasks is <= 0) - { - throw new ArgumentOutOfRangeException( - nameof(maxTasks), - maxTasks, - "Max tasks must be positive."); - } - - if (maxTasksPerSession is <= 0) - { - throw new ArgumentOutOfRangeException( - nameof(maxTasksPerSession), - maxTasksPerSession, - "Max tasks per session must be positive."); - } - - _defaultTtl = defaultTtl; - _maxTtl = maxTtl; - _pollInterval = pollInterval.Value; - _pageSize = pageSize; - _maxTasks = maxTasks; - _maxTasksPerSession = maxTasksPerSession; -#if MCP_TEST_TIME_PROVIDER - _timeProvider = TimeProvider.System; -#endif - - cleanupInterval ??= TimeSpan.FromMinutes(1); - if (cleanupInterval.Value != Timeout.InfiniteTimeSpan) - { -#if MCP_TEST_TIME_PROVIDER - _cleanupTimer = _timeProvider.CreateTimer(CleanupExpiredTasks, null, cleanupInterval.Value, cleanupInterval.Value); -#else - _cleanupTimer = new Timer(CleanupExpiredTasks, null, cleanupInterval.Value, cleanupInterval.Value); -#endif - } - } - -#if MCP_TEST_TIME_PROVIDER - /// - /// Initializes a new instance of the class with a custom time provider. - /// This constructor is only available for testing purposes. - /// - internal InMemoryMcpTaskStore( - TimeSpan? defaultTtl, - TimeSpan? maxTtl, - TimeSpan? pollInterval, - TimeSpan? cleanupInterval, - int pageSize, - int? maxTasks, - int? maxTasksPerSession, - TimeProvider timeProvider) - : this(defaultTtl, maxTtl, pollInterval, cleanupInterval, pageSize, maxTasks, maxTasksPerSession) - { - _timeProvider = timeProvider ?? TimeProvider.System; - } -#endif - - /// - public Task CreateTaskAsync( - McpTaskMetadata taskParams, - RequestId requestId, - JsonRpcRequest request, - string? sessionId = null, - CancellationToken cancellationToken = default) - { - // Check global task limit - if (_maxTasks is { } maxTasks && _tasks.Count >= maxTasks) - { - throw new InvalidOperationException( - $"Maximum number of tasks ({maxTasks}) has been reached. Cannot create new task."); - } - - // Check per-session task limit - if (_maxTasksPerSession is { } maxPerSession && sessionId is not null) - { - var sessionTaskCount = _tasks.Values.Count(e => e.SessionId == sessionId && !IsExpired(e)); - if (sessionTaskCount >= maxPerSession) - { - throw new InvalidOperationException( - $"Maximum number of tasks per session ({maxPerSession}) has been reached for session '{sessionId}'. Cannot create new task."); - } - } - - var taskId = GenerateTaskId(); - var now = GetUtcNow(); - - // Determine TTL: use requested, fall back to default, respect max limit - var ttl = taskParams.TimeToLive ?? _defaultTtl; - if (ttl is { } ttlValue && _maxTtl is { } maxTtlValue && ttlValue > maxTtlValue) - { - ttl = maxTtlValue; - } - - TaskEntry entry = new() - { - TaskId = taskId, - Status = McpTaskStatus.Working, - CreatedAt = now, - LastUpdatedAt = now, - TimeToLive = ttl, - PollInterval = _pollInterval, - RequestId = requestId, - Request = request, - SessionId = sessionId - }; - - if (!_tasks.TryAdd(taskId, entry)) - { - // This should be extremely rare with GUID-based IDs - throw new InvalidOperationException($"Task ID collision: {taskId}"); - } - - return Task.FromResult(entry.ToMcpTask()); - } - - /// - public Task GetTaskAsync(string taskId, string? sessionId = null, CancellationToken cancellationToken = default) - { - if (!_tasks.TryGetValue(taskId, out var entry)) - { - return Task.FromResult(null); - } - - // Enforce session isolation if sessionId is provided - if (sessionId != null && entry.SessionId != sessionId) - { - return Task.FromResult(null); - } - - return Task.FromResult(entry.ToMcpTask()); - } - - /// - public Task StoreTaskResultAsync( - string taskId, - McpTaskStatus status, - JsonElement result, - string? sessionId = null, - CancellationToken cancellationToken = default) - { - if (status is not (McpTaskStatus.Completed or McpTaskStatus.Failed)) - { - throw new ArgumentException( - $"Status must be {nameof(McpTaskStatus.Completed)} or {nameof(McpTaskStatus.Failed)}.", - nameof(status)); - } - - // Retry loop for optimistic concurrency - while (true) - { - if (!_tasks.TryGetValue(taskId, out var entry)) - { - throw new InvalidOperationException($"Task not found: {taskId}"); - } - - // Enforce session isolation - if (sessionId != null && entry.SessionId != sessionId) - { - throw new InvalidOperationException($"Task not found: {taskId}"); - } - - // Prevent overwriting terminal state - if (IsTerminalStatus(entry.Status)) - { - throw new InvalidOperationException( - $"Cannot store result for task in terminal state: {entry.Status}"); - } - - var updatedEntry = new TaskEntry(entry) - { - Status = status, - LastUpdatedAt = GetUtcNow(), - StoredResult = result - }; - - if (_tasks.TryUpdate(taskId, updatedEntry, entry)) - { - return Task.FromResult(updatedEntry.ToMcpTask()); - } - - // Entry was modified by another thread, retry - } - } - - /// - public Task GetTaskResultAsync(string taskId, string? sessionId = null, CancellationToken cancellationToken = default) - { - if (!_tasks.TryGetValue(taskId, out var entry)) - { - throw new InvalidOperationException($"Task not found: {taskId}"); - } - - // Enforce session isolation - if (sessionId != entry.SessionId) - { - throw new InvalidOperationException($"Invalid sessionId: {sessionId} provided for {taskId}"); - } - - if (entry.StoredResult is not { } storedResult) - { - throw new InvalidOperationException($"No result stored for task: {taskId}"); - } - - return Task.FromResult(storedResult); - } - - /// - public Task UpdateTaskStatusAsync( - string taskId, - McpTaskStatus status, - string? statusMessage, - string? sessionId = null, - CancellationToken cancellationToken = default) - { - // Retry loop for optimistic concurrency - while (true) - { - if (!_tasks.TryGetValue(taskId, out var entry)) - { - throw new InvalidOperationException($"Task not found: {taskId}"); - } - - // Enforce session isolation - if (sessionId != null && entry.SessionId != sessionId) - { - throw new InvalidOperationException($"Task not found: {taskId}"); - } - - var updatedEntry = new TaskEntry(entry) - { - Status = status, - StatusMessage = statusMessage, - LastUpdatedAt = GetUtcNow(), - }; - - if (_tasks.TryUpdate(taskId, updatedEntry, entry)) - { - return Task.FromResult(updatedEntry.ToMcpTask()); - } - - // Entry was modified by another thread, retry - } - } - - /// - public Task ListTasksAsync( - string? cursor = null, - string? sessionId = null, - CancellationToken cancellationToken = default) - { - // Stream enumeration - filter by session, exclude expired, apply keyset pagination - var query = _tasks.Values - .Where(e => sessionId == null || e.SessionId == sessionId) - .Where(e => !IsExpired(e)); - - // Apply keyset filter if cursor provided: TaskId > cursor - // UUID v7 task IDs are monotonically increasing and inherently time-ordered - if (cursor != null) - { - query = query.Where(e => string.CompareOrdinal(e.TaskId, cursor) > 0); - } - - // Order by TaskId for stable, deterministic pagination - // UUID v7 task IDs sort chronologically due to embedded timestamp - var page = query - .OrderBy(e => e.TaskId, StringComparer.Ordinal) - .Take(_pageSize + 1) // Take one extra to check if there's a next page - .Select(e => e.ToMcpTask()) - .ToList(); - - // Set nextCursor if we have more results - string? nextCursor; - if (page.Count > _pageSize) - { - var lastItemInPage = page[_pageSize - 1]; // Last item we'll actually return - nextCursor = lastItemInPage.TaskId; - page.RemoveAt(_pageSize); // Remove the extra item - } - else - { - nextCursor = null; - } - - return Task.FromResult(new ListTasksResult - { - Tasks = page.ToArray(), - NextCursor = nextCursor - }); - } - - /// - public Task CancelTaskAsync(string taskId, string? sessionId = null, CancellationToken cancellationToken = default) - { - // Retry loop for optimistic concurrency - while (true) - { - if (!_tasks.TryGetValue(taskId, out var entry)) - { - throw new InvalidOperationException($"Task not found: {taskId}"); - } - - // Enforce session isolation - if (sessionId != null && entry.SessionId != sessionId) - { - throw new InvalidOperationException($"Task not found: {taskId}"); - } - - // If already in terminal state, return unchanged - if (IsTerminalStatus(entry.Status)) - { - return Task.FromResult(entry.ToMcpTask()); - } - - var updatedEntry = new TaskEntry(entry) - { - Status = McpTaskStatus.Cancelled, - LastUpdatedAt = GetUtcNow(), - }; - - if (_tasks.TryUpdate(taskId, updatedEntry, entry)) - { - return Task.FromResult(updatedEntry.ToMcpTask()); - } - - // Entry was modified by another thread, retry - } - } - - /// - /// Disposes the task store and stops background cleanup. - /// - public void Dispose() - { - _cleanupTimer?.Dispose(); - } - - private string GenerateTaskId() => - IdHelpers.CreateMonotonicId(GetUtcNow()); - - private static bool IsTerminalStatus(McpTaskStatus status) => - status is McpTaskStatus.Completed or McpTaskStatus.Failed or McpTaskStatus.Cancelled; - -#if MCP_TEST_TIME_PROVIDER - private DateTimeOffset GetUtcNow() => _timeProvider.GetUtcNow(); -#else - private static DateTimeOffset GetUtcNow() => DateTimeOffset.UtcNow; -#endif - -#if MCP_TEST_TIME_PROVIDER - private bool IsExpired(TaskEntry entry) -#else - private static bool IsExpired(TaskEntry entry) -#endif - { - if (entry.TimeToLive == null) - { - return false; // Unlimited lifetime - } - - var expirationTime = entry.CreatedAt + entry.TimeToLive.Value; - return GetUtcNow() >= expirationTime; - } - - private void CleanupExpiredTasks(object? state) - { - var expiredTaskIds = _tasks - .Where(kvp => IsExpired(kvp.Value)) - .Select(kvp => kvp.Key) - .ToList(); - - foreach (var taskId in expiredTaskIds) - { - _tasks.TryRemove(taskId, out _); - } - } - - private sealed class TaskEntry - { - // Flattened McpTask properties - public required string TaskId { get; init; } - public required McpTaskStatus Status { get; init; } - public string? StatusMessage { get; init; } - public required DateTimeOffset CreatedAt { get; init; } - public required DateTimeOffset LastUpdatedAt { get; init; } - public TimeSpan? TimeToLive { get; init; } - public TimeSpan? PollInterval { get; init; } - - // Request metadata - public required RequestId RequestId { get; init; } - public required JsonRpcRequest Request { get; init; } - public required string? SessionId { get; init; } - public JsonElement? StoredResult { get; init; } - - /// - /// Copy constructor for creating modified copies. - /// - [SetsRequiredMembers] - public TaskEntry(TaskEntry source) - { - TaskId = source.TaskId; - Status = source.Status; - StatusMessage = source.StatusMessage; - CreatedAt = source.CreatedAt; - LastUpdatedAt = source.LastUpdatedAt; - TimeToLive = source.TimeToLive; - PollInterval = source.PollInterval; - RequestId = source.RequestId; - Request = source.Request; - SessionId = source.SessionId; - StoredResult = source.StoredResult; - } - - /// - /// Default constructor for initial creation. - /// - public TaskEntry() { } - - /// - /// Converts this entry back to an McpTask for external consumption. - /// - public McpTask ToMcpTask() => new() - { - TaskId = TaskId, - Status = Status, - StatusMessage = StatusMessage, - CreatedAt = CreatedAt, - LastUpdatedAt = LastUpdatedAt, - TimeToLive = TimeToLive, - PollInterval = PollInterval - }; - } -} diff --git a/src/ModelContextProtocol.Core/Server/McpHeaderAttribute.cs b/src/ModelContextProtocol.Core/Server/McpHeaderAttribute.cs new file mode 100644 index 000000000..d81523a56 --- /dev/null +++ b/src/ModelContextProtocol.Core/Server/McpHeaderAttribute.cs @@ -0,0 +1,80 @@ +using ModelContextProtocol.Client; + +namespace ModelContextProtocol.Server; + +/// +/// Indicates that a tool parameter should be mirrored as an HTTP header in client requests. +/// +/// +/// +/// When applied to a parameter, the SDK will include an x-mcp-header extension property +/// in the parameter's JSON schema. Clients will then mirror this parameter's value into an +/// HTTP header named Mcp-Param-{Name}. +/// +/// +/// Only parameters with primitive types (integer, string, boolean) may use this attribute. +/// The header name must match HTTP field-name token syntax (tchar per RFC 9110 Section 5.6.2) +/// and must be case-insensitively unique within the tool's input schema. +/// +/// +/// This enables network infrastructure such as load balancers, proxies, and gateways to make +/// routing decisions based on tool parameter values without parsing the JSON-RPC request body. +/// +/// +/// +/// +/// [McpServerTool] +/// public static string ExecuteSql( +/// [McpHeader("Region")] string region, +/// string query) +/// { +/// // The client will add header: Mcp-Param-Region: {region value} +/// } +/// +/// +[AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property)] +public sealed class McpHeaderAttribute : Attribute +{ + /// + /// Initializes a new instance of the class. + /// + /// + /// The name portion of the header. The full header name will be Mcp-Param-{name}. + /// Must match HTTP field-name token syntax (tchar per RFC 9110 Section 5.6.2). + /// + /// + /// The name is null, empty, or contains invalid characters. + /// + public McpHeaderAttribute(string name) + { + Throw.IfNullOrWhiteSpace(name); + ValidateHeaderName(name); + Name = name; + } + + /// + /// Gets the name portion of the header. + /// + /// + /// The full header name sent by clients will be Mcp-Param-{Name}. + /// + public string Name { get; } + + /// + /// Validates that a header name contains only valid HTTP token characters (tchar) per RFC 9110 Section 5.6.2. + /// + /// The header name to validate. + /// The name contains invalid characters. + internal static void ValidateHeaderName(string name) + { + int idx = McpHeaderExtractor.FindFirstNonTchar(name); + if (idx >= 0) + { + char c = name[idx]; + throw new ArgumentException( + $"Header name contains invalid character '{c}' (0x{(int)c:X2}). " + + "Only HTTP token characters (tchar per RFC 9110 Section 5.6.2) are allowed.", + nameof(name)); + } + } +} diff --git a/src/ModelContextProtocol.Core/Server/McpRequestFilters.cs b/src/ModelContextProtocol.Core/Server/McpRequestFilters.cs index 5044f8928..a1aad7112 100644 --- a/src/ModelContextProtocol.Core/Server/McpRequestFilters.cs +++ b/src/ModelContextProtocol.Core/Server/McpRequestFilters.cs @@ -1,4 +1,5 @@ using ModelContextProtocol.Protocol; +using System.Diagnostics.CodeAnalysis; namespace ModelContextProtocol.Server; @@ -7,6 +8,9 @@ namespace ModelContextProtocol.Server; /// public sealed class McpRequestFilters { +#pragma warning disable MCPEXP002 // CallToolWithAlternateFilters references the experimental ResultOrAlternate seam + private IList>? _callToolFilters; + /// /// Gets or sets the filters for the list-tools handler pipeline. /// @@ -36,11 +40,52 @@ public IList> ListTool /// Gets or sets the filters for the call-tool handler pipeline. /// /// + /// /// These filters wrap handlers that are invoked when a client makes a call to a tool that isn't found in the collection. /// The filters can modify, log, or perform additional operations on requests and responses for /// requests. The handler should implement logic to execute the requested tool and return appropriate results. + /// + /// + /// These filters run inside . Each ordinary filter runs exactly once + /// when an alternate-result filter invokes the ordinary tool pipeline. For task-backed calls, that invocation + /// occurs in the background after the task record is created and before the matched tool is executed. Filters + /// that must run before task creation should use the alternate-result pipeline instead. + /// + /// + /// These filters cannot be used with an explicit , + /// which replaces the ordinary tool-call pipeline rather than augmenting it. + /// /// public IList> CallToolFilters + { + get => _callToolFilters ??= []; + set + { + Throw.IfNull(value); + _callToolFilters = value; + } + } + + /// + /// Gets or sets the filters for the call-tool handler pipeline with alternate result support. + /// + /// + /// + /// These filters wrap the alternate-result call-tool handler whose return type is + /// . Use these filters when the server's tool pipeline + /// supports returning either an immediate or an alternate + /// subtype for asynchronous execution. + /// + /// + /// When no explicit is configured, these filters + /// compose outside . Primitive matching occurs before either filter family runs, then + /// the ordinary pipeline is adapted to before these filters are applied. + /// Alternate-result filters run in registration order. If one filter dispatches the remainder of the pipeline + /// asynchronously, filters registered after it execute as part of that asynchronous operation. + /// + /// + [Experimental(Experimentals.Extensibility_DiagnosticId, UrlFormat = Experimentals.Extensibility_Url)] + public IList>> CallToolWithAlternateFilters { get => field ??= []; set @@ -49,6 +94,7 @@ public IList> CallToolFi field = value; } } +#pragma warning restore MCPEXP002 /// /// Gets or sets the filters for the list-prompts handler pipeline. @@ -233,6 +279,7 @@ public IList> Unsubscrib /// at or above the specified level to the client as notifications/message notifications. /// /// + [Obsolete(Obsoletions.DeprecatedLogging_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public IList> SetLoggingLevelFilters { get => field ??= []; diff --git a/src/ModelContextProtocol.Core/Server/McpRequestInvocationFilter.cs b/src/ModelContextProtocol.Core/Server/McpRequestInvocationFilter.cs new file mode 100644 index 000000000..baacf4fcc --- /dev/null +++ b/src/ModelContextProtocol.Core/Server/McpRequestInvocationFilter.cs @@ -0,0 +1,18 @@ +using System.Diagnostics.CodeAnalysis; + +namespace ModelContextProtocol.Server; + +/// +/// Delegate type for filtering a single incoming MCP request invocation. +/// +/// The type of the parameters sent with the request. +/// The type of the response returned by the handler. +/// The context for the current request. +/// The next request handler in the pipeline for this invocation. +/// The cancellation token for the current request. +/// The result of the filtered request invocation. +[Experimental(Experimentals.Extensibility_DiagnosticId, UrlFormat = Experimentals.Extensibility_Url)] +public delegate ValueTask McpRequestInvocationFilter( + RequestContext context, + McpRequestHandler next, + CancellationToken cancellationToken); diff --git a/src/ModelContextProtocol.Core/Server/McpServer.Methods.cs b/src/ModelContextProtocol.Core/Server/McpServer.Methods.cs index 3caaca5a6..a9a5dddfb 100644 --- a/src/ModelContextProtocol.Core/Server/McpServer.Methods.cs +++ b/src/ModelContextProtocol.Core/Server/McpServer.Methods.cs @@ -23,6 +23,29 @@ public abstract partial class McpServer : McpSession private static Dictionary>? s_elicitAllowedProperties = null; + internal virtual Func>? OutgoingRequestInterceptor => null; + + /// + /// Creates a non-mutating server facade that redirects server-initiated requests through an interceptor. + /// + /// + /// The interceptor invoked for each outgoing request. It receives the request method, the + /// pre-serialized request parameters (or ), and a cancellation token, and + /// returns the serialized result (or to indicate no result). + /// + /// A server facade that uses for outgoing requests. + /// is . + /// + /// On the returned facade, redirected methods skip their client-capability checks, + /// because the alternate channel is responsible for delivering the request to the client. + /// + [Experimental(Experimentals.Extensibility_DiagnosticId, UrlFormat = Experimentals.Extensibility_Url)] + public McpServer WithOutgoingRequestInterceptor(Func> interceptor) + { + Throw.IfNull(interceptor); + return new OutgoingRequestInterceptingMcpServer(this, interceptor); + } + /// /// Creates a new instance of an . /// @@ -54,62 +77,41 @@ public static McpServer Create( /// The client does not support sampling. /// The request failed or the client returned an error response. /// - /// When called during task-augmented tool execution, this method automatically updates the task - /// status to while waiting for the client response, - /// then returns to when the response is received. + /// + /// When the server is using the Streamable HTTP transport, prefer calling this method on the + /// instance available via RequestContext from inside a tool, prompt, + /// or resource handler. That routes the request through the originating POST response stream via + /// , which is always open for the duration of + /// the request, rather than relying on the optional standalone GET SSE stream. + /// /// - public async ValueTask SampleAsync( + [Obsolete(Obsoletions.DeprecatedSampling_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] + public ValueTask SampleAsync( CreateMessageRequestParams requestParams, CancellationToken cancellationToken = default) { Throw.IfNull(requestParams); - ThrowIfSamplingUnsupported(); - return await SendRequestWithTaskStatusTrackingAsync( - RequestMethods.SamplingCreateMessage, - requestParams, - McpJsonUtilities.JsonContext.Default.CreateMessageRequestParams, - McpJsonUtilities.JsonContext.Default.CreateMessageResult, - "Waiting for sampling response", - cancellationToken).ConfigureAwait(false); - } + // If an outgoing-request interceptor is installed (e.g., during background task execution), + // redirect sampling through it. Capability checks (ThrowIfSamplingUnsupported) are + // intentionally skipped because the interceptor's alternate channel is responsible for + // delivering the request to the client. See SendRequestViaInterceptorAsync remarks. + if (OutgoingRequestInterceptor is { } interceptor) + { + return SendRequestViaInterceptorAsync(interceptor, RequestMethods.SamplingCreateMessage, requestParams, + McpJsonUtilities.JsonContext.Default.CreateMessageRequestParams, + McpJsonUtilities.JsonContext.Default.CreateMessageResult, + cancellationToken); + } - /// - /// Requests to sample an LLM via the client as a task, allowing the server to poll for completion. - /// - /// The parameters for the sampling request. - /// The task metadata specifying TTL and other task-related options. - /// The to monitor for cancellation requests. - /// An representing the created task on the client. - /// or is . - /// The client does not support sampling or task-augmented sampling. - /// The request failed or the client returned an error response. - /// - /// Use to poll for task status and - /// (with ) to retrieve the final result when the task completes. - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - public async ValueTask SampleAsTaskAsync( - CreateMessageRequestParams requestParams, - McpTaskMetadata taskMetadata, - CancellationToken cancellationToken = default) - { - Throw.IfNull(requestParams); - Throw.IfNull(taskMetadata); ThrowIfSamplingUnsupported(); - ThrowIfTasksUnsupportedForSampling(); - - // Set the task metadata on the request - requestParams.Task = taskMetadata; - var result = await SendRequestAsync( + return SendRequestAsync( RequestMethods.SamplingCreateMessage, requestParams, McpJsonUtilities.JsonContext.Default.CreateMessageRequestParams, - McpJsonUtilities.JsonContext.Default.CreateTaskResult, - cancellationToken: cancellationToken).ConfigureAwait(false); - - return result.Task; + McpJsonUtilities.JsonContext.Default.CreateMessageResult, + cancellationToken: cancellationToken); } /// @@ -123,6 +125,7 @@ public async ValueTask SampleAsTaskAsync( /// is . /// The client does not support sampling. /// The request failed or the client returned an error response. + [Obsolete(Obsoletions.DeprecatedSampling_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public async Task SampleAsync( IEnumerable messages, ChatOptions? chatOptions = default, JsonSerializerOptions? serializerOptions = null, CancellationToken cancellationToken = default) { @@ -252,6 +255,14 @@ public async Task SampleAsync( /// The to use for serialization. If , is used. /// The that can be used to issue sampling requests to the client. /// The client does not support sampling. + /// + /// When the server is using the Streamable HTTP transport, prefer obtaining this chat client from the + /// instance available via RequestContext from inside a tool, prompt, + /// or resource handler. That routes sampling requests through the originating POST response stream via + /// , which is always open for the duration of + /// the request, rather than relying on the optional standalone GET SSE stream. + /// + [Obsolete(Obsoletions.DeprecatedSampling_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public IChatClient AsSamplingChatClient(JsonSerializerOptions? serializerOptions = null) { ThrowIfSamplingUnsupported(); @@ -261,6 +272,7 @@ public IChatClient AsSamplingChatClient(JsonSerializerOptions? serializerOptions /// Gets an on which logged messages will be sent as notifications to the client. /// An that can be used to log to the client. + [Obsolete(Obsoletions.DeprecatedLogging_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public ILoggerProvider AsClientLoggerProvider() => new ClientLoggerProvider(this); @@ -273,11 +285,32 @@ public ILoggerProvider AsClientLoggerProvider() => /// is . /// The client does not support roots. /// The request failed or the client returned an error response. + /// + /// When the server is using the Streamable HTTP transport, prefer calling this method on the + /// instance available via RequestContext from inside a tool, prompt, + /// or resource handler. That routes the request through the originating POST response stream via + /// , which is always open for the duration of + /// the request, rather than relying on the optional standalone GET SSE stream. + /// + [Obsolete(Obsoletions.DeprecatedRoots_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public ValueTask RequestRootsAsync( ListRootsRequestParams requestParams, CancellationToken cancellationToken = default) { Throw.IfNull(requestParams); + + // If an outgoing-request interceptor is installed (e.g., during background task execution), + // redirect through it. Capability checks (ThrowIfRootsUnsupported) are intentionally skipped + // because the interceptor's alternate channel is responsible for delivering the request to + // the client. See SendRequestViaInterceptorAsync remarks. + if (OutgoingRequestInterceptor is { } interceptor) + { + return SendRequestViaInterceptorAsync(interceptor, RequestMethods.RootsList, requestParams, + McpJsonUtilities.JsonContext.Default.ListRootsRequestParams, + McpJsonUtilities.JsonContext.Default.ListRootsResult, + cancellationToken); + } + ThrowIfRootsUnsupported(); return SendRequestAsync( @@ -298,359 +331,41 @@ public ValueTask RequestRootsAsync( /// The client does not support elicitation. /// The request failed or the client returned an error response. /// - /// When called during task-augmented tool execution, this method automatically updates the task - /// status to while waiting for user input, - /// then returns to when the response is received. + /// + /// When the server is using the Streamable HTTP transport, prefer calling this method on the + /// instance available via RequestContext from inside a tool, prompt, + /// or resource handler. That routes the request through the originating POST response stream via + /// , which is always open for the duration of + /// the request, rather than relying on the optional standalone GET SSE stream. + /// /// public async ValueTask ElicitAsync( ElicitRequestParams requestParams, CancellationToken cancellationToken = default) { Throw.IfNull(requestParams); - ThrowIfElicitationUnsupported(requestParams); - var result = await SendRequestWithTaskStatusTrackingAsync( - RequestMethods.ElicitationCreate, - requestParams, - McpJsonUtilities.JsonContext.Default.ElicitRequestParams, - McpJsonUtilities.JsonContext.Default.ElicitResult, - "Waiting for user input", - cancellationToken).ConfigureAwait(false); - - return ElicitResult.WithDefaults(requestParams, result); - } + // If an outgoing-request interceptor is installed (e.g., during background task execution), + // redirect elicitation through it. Capability checks (ThrowIfElicitationUnsupported) are + // intentionally skipped because the interceptor's alternate channel is responsible for + // delivering the request to the client. See SendRequestViaInterceptorAsync remarks. + if (OutgoingRequestInterceptor is { } interceptor) + { + var paramsNode = JsonSerializer.SerializeToNode(requestParams, McpJsonUtilities.JsonContext.Default.ElicitRequestParams); + var resultNode = await interceptor(RequestMethods.ElicitationCreate, paramsNode, cancellationToken).ConfigureAwait(false); + return resultNode?.Deserialize(McpJsonUtilities.JsonContext.Default.ElicitResult) ?? new ElicitResult { Action = "cancel" }; + } - /// - /// Requests additional information from the user via the client as a task, allowing the server to poll for completion. - /// - /// The parameters for the elicitation request. - /// The task metadata specifying TTL and other task-related options. - /// The to monitor for cancellation requests. - /// An representing the created task on the client. - /// or is . - /// The client does not support elicitation or task-augmented elicitation. - /// The request failed or the client returned an error response. - /// - /// Use to poll for task status and - /// (with ) to retrieve the final result when the task completes. - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - public async ValueTask ElicitAsTaskAsync( - ElicitRequestParams requestParams, - McpTaskMetadata taskMetadata, - CancellationToken cancellationToken = default) - { - Throw.IfNull(requestParams); - Throw.IfNull(taskMetadata); ThrowIfElicitationUnsupported(requestParams); - ThrowIfTasksUnsupportedForElicitation(); - - // Set the task metadata on the request - requestParams.Task = taskMetadata; var result = await SendRequestAsync( RequestMethods.ElicitationCreate, requestParams, McpJsonUtilities.JsonContext.Default.ElicitRequestParams, - McpJsonUtilities.JsonContext.Default.CreateTaskResult, - cancellationToken: cancellationToken).ConfigureAwait(false); - - return result.Task; - } - - /// - /// Retrieves the current state of a specific task from the client. - /// - /// The unique identifier of the task to retrieve. - /// The to monitor for cancellation requests. The default is . - /// The current state of the task. - /// is . - /// is empty or composed entirely of whitespace. - /// The client does not support tasks. - /// The request failed or the client returned an error response. - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - public async ValueTask GetTaskAsync( - string taskId, - CancellationToken cancellationToken = default) - { - Throw.IfNullOrWhiteSpace(taskId); - ThrowIfTasksUnsupported(); - - var result = await SendRequestAsync( - RequestMethods.TasksGet, - new GetTaskRequestParams { TaskId = taskId }, - McpJsonUtilities.JsonContext.Default.GetTaskRequestParams, - McpJsonUtilities.JsonContext.Default.GetTaskResult, - cancellationToken: cancellationToken).ConfigureAwait(false); - - // Convert GetTaskResult to McpTask - return new McpTask - { - TaskId = result.TaskId, - Status = result.Status, - StatusMessage = result.StatusMessage, - CreatedAt = result.CreatedAt, - LastUpdatedAt = result.LastUpdatedAt, - TimeToLive = result.TimeToLive, - PollInterval = result.PollInterval - }; - } - - /// - /// Retrieves the result of a completed task from the client, blocking until the task reaches a terminal state. - /// - /// The type to deserialize the task result into. - /// The unique identifier of the task whose result to retrieve. - /// Optional serializer options for deserializing the result. - /// The to monitor for cancellation requests. The default is . - /// The result of the task, deserialized into type . - /// is . - /// is empty or composed entirely of whitespace. - /// The client does not support tasks. - /// The request failed or the client returned an error response. - /// - /// - /// This method sends a tasks/result request to the client, which will block until the task completes if it hasn't already. - /// The client handles all polling logic internally. - /// - /// - /// For sampling tasks, use as . - /// For elicitation tasks, use as . - /// - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - public async ValueTask GetTaskResultAsync( - string taskId, - JsonSerializerOptions? jsonSerializerOptions = null, - CancellationToken cancellationToken = default) - { - Throw.IfNullOrWhiteSpace(taskId); - ThrowIfTasksUnsupported(); - - var result = await SendRequestAsync( - RequestMethods.TasksResult, - new GetTaskPayloadRequestParams { TaskId = taskId }, - McpJsonUtilities.JsonContext.Default.GetTaskPayloadRequestParams, - McpJsonUtilities.JsonContext.Default.JsonElement, - cancellationToken: cancellationToken).ConfigureAwait(false); - - var serializerOptions = jsonSerializerOptions ?? McpJsonUtilities.DefaultOptions; - serializerOptions.MakeReadOnly(); - - var typeInfo = serializerOptions.GetTypeInfo(); - return result.Deserialize(typeInfo); - } - - /// - /// Retrieves a list of all tasks from the client. - /// - /// The to monitor for cancellation requests. The default is . - /// A list of all tasks. - /// The client does not support tasks or task listing. - /// The request failed or the client returned an error response. - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - public async ValueTask> ListTasksAsync( - CancellationToken cancellationToken = default) - { - ThrowIfTasksUnsupported(); - ThrowIfTaskListingUnsupported(); - - List? tasks = null; - ListTasksRequestParams requestParams = new(); - do - { - var taskResults = await ListTasksAsync(requestParams, cancellationToken).ConfigureAwait(false); - if (tasks is null) - { - tasks = new List(taskResults.Tasks.Count); - } - - foreach (var mcpTask in taskResults.Tasks) - { - tasks.Add(mcpTask); - } - - requestParams.Cursor = taskResults.NextCursor; - } - while (requestParams.Cursor is not null); - - return tasks; - } - - /// - /// Retrieves a list of tasks from the client. - /// - /// The request parameters to send in the request. - /// The to monitor for cancellation requests. The default is . - /// The result of the request as provided by the client. - /// is . - /// The client does not support tasks or task listing. - /// The request failed or the client returned an error response. - /// - /// The overload retrieves all tasks by automatically handling pagination. - /// This overload works with the lower-level and , returning the raw result from the client. - /// Any pagination needs to be managed by the caller. - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - public ValueTask ListTasksAsync( - ListTasksRequestParams requestParams, - CancellationToken cancellationToken = default) - { - Throw.IfNull(requestParams); - ThrowIfTasksUnsupported(); - ThrowIfTaskListingUnsupported(); - - return SendRequestAsync( - RequestMethods.TasksList, - requestParams, - McpJsonUtilities.JsonContext.Default.ListTasksRequestParams, - McpJsonUtilities.JsonContext.Default.ListTasksResult, - cancellationToken: cancellationToken); - } - - /// - /// Cancels a running task on the client. - /// - /// The unique identifier of the task to cancel. - /// The to monitor for cancellation requests. The default is . - /// The updated state of the task after cancellation. - /// is . - /// is empty or composed entirely of whitespace. - /// The client does not support tasks or task cancellation. - /// The request failed or the client returned an error response. - /// - /// Cancelling a task requests that the client stop execution. The client may not immediately cancel the task, - /// and may choose to allow the task to complete if it's close to finishing. - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - public async ValueTask CancelTaskAsync( - string taskId, - CancellationToken cancellationToken = default) - { - Throw.IfNullOrWhiteSpace(taskId); - ThrowIfTasksUnsupported(); - ThrowIfTaskCancellationUnsupported(); - - var result = await SendRequestAsync( - RequestMethods.TasksCancel, - new CancelMcpTaskRequestParams { TaskId = taskId }, - McpJsonUtilities.JsonContext.Default.CancelMcpTaskRequestParams, - McpJsonUtilities.JsonContext.Default.CancelMcpTaskResult, + McpJsonUtilities.JsonContext.Default.ElicitResult, cancellationToken: cancellationToken).ConfigureAwait(false); - // Convert CancelMcpTaskResult to McpTask - return new McpTask - { - TaskId = result.TaskId, - Status = result.Status, - StatusMessage = result.StatusMessage, - CreatedAt = result.CreatedAt, - LastUpdatedAt = result.LastUpdatedAt, - TimeToLive = result.TimeToLive, - PollInterval = result.PollInterval - }; - } - - /// - /// Polls a task on the client until it reaches a terminal state. - /// - /// The unique identifier of the task to poll. - /// The to monitor for cancellation requests. The default is . - /// The task in its terminal state. - /// is . - /// is empty or composed entirely of whitespace. - /// The client does not support tasks. - /// The request failed or the client returned an error response. - /// - /// - /// This method repeatedly calls until the task reaches a terminal status. - /// It respects the returned by the client to determine how long - /// to wait between polling attempts. - /// - /// - /// For retrieving the actual result of a completed task, use - /// or . - /// - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - public async ValueTask PollTaskUntilCompleteAsync( - string taskId, - CancellationToken cancellationToken = default) - { - Throw.IfNullOrWhiteSpace(taskId); - - McpTask task; - do - { - task = await GetTaskAsync(taskId, cancellationToken).ConfigureAwait(false); - - // If task is in a terminal state, we're done - if (task.Status is McpTaskStatus.Completed or McpTaskStatus.Failed or McpTaskStatus.Cancelled) - { - break; - } - - // Wait for the poll interval before checking again (default to 1 second) - var pollInterval = task.PollInterval ?? TimeSpan.FromSeconds(1); - await Task.Delay(pollInterval, cancellationToken).ConfigureAwait(false); - } - while (true); - - return task; - } - - /// - /// Waits for a task on the client to complete and retrieves its result. - /// - /// The type to deserialize the task result into. - /// The unique identifier of the task whose result to retrieve. - /// Optional serializer options for deserializing the result. - /// The to monitor for cancellation requests. The default is . - /// A tuple containing the final task state and its result. - /// is . - /// is empty or composed entirely of whitespace. - /// The client does not support tasks. - /// The task failed or was cancelled. - /// - /// - /// This method combines and - /// to provide a convenient way to wait for a task to complete and retrieve its result in a single call. - /// - /// - /// If the task completes with a status of or , - /// an is thrown. - /// - /// - /// For sampling tasks, use as . - /// For elicitation tasks, use as . - /// - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - public async ValueTask<(McpTask Task, TResult? Result)> WaitForTaskResultAsync( - string taskId, - JsonSerializerOptions? jsonSerializerOptions = null, - CancellationToken cancellationToken = default) - { - Throw.IfNullOrWhiteSpace(taskId); - - // Poll until task reaches terminal state - var task = await PollTaskUntilCompleteAsync(taskId, cancellationToken).ConfigureAwait(false); - - // Check for failure or cancellation - if (task.Status == McpTaskStatus.Failed) - { - throw new McpException($"Task '{taskId}' failed: {task.StatusMessage ?? "Unknown error"}"); - } - - if (task.Status == McpTaskStatus.Cancelled) - { - throw new McpException($"Task '{taskId}' was cancelled"); - } - - // Retrieve the result - var result = await GetTaskResultAsync(taskId, jsonSerializerOptions, cancellationToken).ConfigureAwait(false); - - return (task, result); + return ElicitResult.WithDefaults(requestParams, result); } /// @@ -864,6 +579,40 @@ private void ThrowIfRootsUnsupported() } } + /// + /// Sends a server-initiated request through the installed outgoing-request interceptor, then awaits the response. + /// + /// + /// When an interceptor is installed, capability negotiation checks (such as + /// , , and + /// ) are intentionally skipped by the callers + /// of this helper. The interceptor's alternate channel is the negotiated capability and is + /// responsible for delivering the request to the client or rejecting it. + /// + private async ValueTask SendRequestViaInterceptorAsync( + Func> interceptor, + string method, + TRequest request, + JsonTypeInfo requestTypeInfo, + JsonTypeInfo responseTypeInfo, + CancellationToken cancellationToken) + { + var paramsNode = JsonSerializer.SerializeToNode(request, requestTypeInfo); + var resultNode = await interceptor(method, paramsNode, cancellationToken).ConfigureAwait(false); + if (resultNode is null) + { + // A null result cannot be deserialized into a concrete TResponse (e.g. SampleAsync's + // CreateMessageResult or RequestRootsAsync's ListRootsResult). Returning default! here + // would hand callers a null response typed as non-null, deferring the failure to a + // confusing NullReferenceException at the use site. Fail fast with a clear message. + // Callers that can tolerate no result (such as ElicitAsync) do not route through this + // helper and handle null themselves. + throw new McpException($"The outgoing-request interceptor returned no result for the '{method}' request."); + } + + return resultNode.Deserialize(responseTypeInfo)!; + } + private void ThrowIfElicitationUnsupported(ElicitRequestParams request) { if (ClientCapabilities is null) @@ -908,120 +657,6 @@ private void ThrowIfElicitationUnsupported(ElicitRequestParams request) } } - private void ThrowIfTasksUnsupportedForSampling() - { - if (ClientCapabilities?.Tasks?.Requests?.Sampling?.CreateMessage is null) - { - if (ClientCapabilities is null) - { - throw new InvalidOperationException("Task-augmented sampling is not supported in stateless mode."); - } - - throw new InvalidOperationException("Client does not support task-augmented sampling requests."); - } - } - - private void ThrowIfTasksUnsupportedForElicitation() - { - if (ClientCapabilities?.Tasks?.Requests?.Elicitation?.Create is null) - { - if (ClientCapabilities is null) - { - throw new InvalidOperationException("Task-augmented elicitation is not supported in stateless mode."); - } - - throw new InvalidOperationException("Client does not support task-augmented elicitation requests."); - } - } - - private void ThrowIfTasksUnsupported() - { - if (ClientCapabilities?.Tasks is null) - { - if (ClientCapabilities is null) - { - throw new InvalidOperationException("Tasks are not supported in stateless mode."); - } - - throw new InvalidOperationException("Client does not support tasks."); - } - } - - private void ThrowIfTaskListingUnsupported() - { - if (ClientCapabilities?.Tasks?.List is null) - { - throw new InvalidOperationException("Client does not support task listing."); - } - } - - private void ThrowIfTaskCancellationUnsupported() - { - if (ClientCapabilities?.Tasks?.Cancel is null) - { - throw new InvalidOperationException("Client does not support task cancellation."); - } - } - - /// - /// Sends a request to the client, automatically updating task status to InputRequired during - /// the request when called within a task execution context. - /// - private async ValueTask SendRequestWithTaskStatusTrackingAsync( - string method, - TParams requestParams, - JsonTypeInfo paramsTypeInfo, - JsonTypeInfo resultTypeInfo, - string inputRequiredMessage, - CancellationToken cancellationToken) - where TParams : RequestParams - where TResult : notnull - { - var taskContext = TaskExecutionContext.Current; - - // If we're not in a task execution context, just send the request normally - if (taskContext is null) - { - return await SendRequestAsync(method, requestParams, paramsTypeInfo, resultTypeInfo, cancellationToken: cancellationToken).ConfigureAwait(false); - } - - // Update task status to InputRequired - var inputRequiredTask = await taskContext.TaskStore.UpdateTaskStatusAsync( - taskContext.TaskId, - Protocol.McpTaskStatus.InputRequired, - inputRequiredMessage, - taskContext.SessionId, - CancellationToken.None).ConfigureAwait(false); - - // Send notification if enabled - if (taskContext.SendNotifications && taskContext.NotifyTaskStatusFunc is not null) - { - _ = taskContext.NotifyTaskStatusFunc(inputRequiredTask, CancellationToken.None); - } - - try - { - // Send the actual request - return await SendRequestAsync(method, requestParams, paramsTypeInfo, resultTypeInfo, cancellationToken: cancellationToken).ConfigureAwait(false); - } - finally - { - // Update task status back to Working - var workingTask = await taskContext.TaskStore.UpdateTaskStatusAsync( - taskContext.TaskId, - Protocol.McpTaskStatus.Working, - null, // Clear status message - taskContext.SessionId, - CancellationToken.None).ConfigureAwait(false); - - // Send notification if enabled - if (taskContext.SendNotifications && taskContext.NotifyTaskStatusFunc is not null) - { - _ = taskContext.NotifyTaskStatusFunc(workingTask, CancellationToken.None); - } - } - } - /// Provides an implementation that's implemented via client sampling. private sealed class SamplingChatClient(McpServer server, JsonSerializerOptions serializerOptions) : IChatClient { @@ -1059,50 +694,6 @@ async IAsyncEnumerable IChatClient.GetStreamingResponseAsync void IDisposable.Dispose() { } // nop } - /// - /// Sends a task status notification to the connected client. - /// - /// The task whose status changed. - /// The to monitor for cancellation requests. - /// A task representing the asynchronous notification operation. - /// is . - /// The notification failed or the client returned an error response. - /// - /// - /// This method sends an optional status notification to inform the client of task state changes. - /// According to the MCP specification, receivers MAY send this notification but are not required to. - /// Clients must not rely on receiving these notifications and should continue polling via tasks/get. - /// - /// - /// The notification is sent using the standard notifications/tasks/status method and includes - /// the full task state information. - /// - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - public Task NotifyTaskStatusAsync( - McpTask task, - CancellationToken cancellationToken = default) - { - Throw.IfNull(task); - - var notificationParams = new McpTaskStatusNotificationParams - { - TaskId = task.TaskId, - Status = task.Status, - StatusMessage = task.StatusMessage, - CreatedAt = task.CreatedAt, - LastUpdatedAt = task.LastUpdatedAt, - TimeToLive = task.TimeToLive, - PollInterval = task.PollInterval - }; - - return SendNotificationAsync( - NotificationMethods.TaskStatusNotification, - notificationParams, - McpJsonUtilities.JsonContext.Default.McpTaskStatusNotificationParams, - cancellationToken); - } - /// /// Provides an implementation for creating loggers /// that send logging message notifications to the client for logged messages. diff --git a/src/ModelContextProtocol.Core/Server/McpServer.cs b/src/ModelContextProtocol.Core/Server/McpServer.cs index b8b41bdc3..4797ce151 100644 --- a/src/ModelContextProtocol.Core/Server/McpServer.cs +++ b/src/ModelContextProtocol.Core/Server/McpServer.cs @@ -11,7 +11,7 @@ public abstract partial class McpServer : McpSession /// /// Initializes a new instance of the class. /// - [Experimental(Experimentals.Subclassing_DiagnosticId, UrlFormat = Experimentals.Subclassing_Url)] + [Experimental(Experimentals.Extensibility_DiagnosticId, UrlFormat = Experimentals.Extensibility_Url)] protected McpServer() { } @@ -21,9 +21,19 @@ protected McpServer() /// /// /// - /// These capabilities are established during the initialization handshake and indicate - /// which features the client supports, such as sampling, roots, and other - /// protocol-specific functionality. + /// On protocol revisions that use the initialize handshake (2025-11-25 and earlier), these + /// capabilities are established once during initialization and are session-scoped: they are available both + /// on the root and on the server exposed to request handlers. + /// + /// + /// On the 2026-07-28 revision and later (SEP-2575) there is no initialize handshake; the client + /// declares its capabilities per-request in _meta, and the server MUST NOT infer them from previous + /// requests. In that mode this property is only meaningful on the request-scoped server accessed via + /// the Server property of the passed to a handler; on the + /// root (for example one constructed manually over a + /// ) it is . + /// It is also in stateless transport mode, where server-to-client requests are + /// unsupported. /// /// /// Server implementations can check these capabilities to determine which features @@ -38,7 +48,14 @@ protected McpServer() /// /// /// This property contains identification information about the client that has connected to this server, - /// including its name and version. This information is provided by the client during initialization. + /// including its name and version. + /// + /// + /// On protocol revisions that use the initialize handshake (2025-11-25 and earlier) this + /// information is provided once during initialization and is session-scoped. On the 2026-07-28 + /// revision and later it is carried per-request in _meta, so read it from the request-scoped server + /// accessed via the Server property of the passed to a handler + /// rather than from the root . /// /// /// Server implementations can use this information for logging, tracking client versions, @@ -62,8 +79,27 @@ protected McpServer() public abstract IServiceProvider? Services { get; } /// Gets the last logging level set by the client, or if it's never been set. + [Obsolete(Obsoletions.DeprecatedLogging_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public abstract LoggingLevel? LoggingLevel { get; } + /// + /// Gets a value indicating whether the connected client supports Multi Round-Trip Requests (MRTR). + /// + /// + /// + /// When this property returns , tool handlers can throw + /// to return an + /// with and/or + /// to the client. + /// + /// + /// When this property returns , tool handlers should provide a fallback + /// experience (for example, returning a text message explaining that the client does not support + /// the required feature) instead of throwing . + /// + /// + public virtual bool IsMrtrSupported => false; + /// /// Runs the server, listening for and handling client requests. /// diff --git a/src/ModelContextProtocol.Core/Server/McpServerHandlers.cs b/src/ModelContextProtocol.Core/Server/McpServerHandlers.cs index 6dbcea8af..4e74cb948 100644 --- a/src/ModelContextProtocol.Core/Server/McpServerHandlers.cs +++ b/src/ModelContextProtocol.Core/Server/McpServerHandlers.cs @@ -1,4 +1,5 @@ using ModelContextProtocol.Protocol; +using System.Diagnostics.CodeAnalysis; namespace ModelContextProtocol.Server; @@ -36,14 +37,63 @@ public sealed class McpServerHandlers /// public McpRequestHandler? ListToolsHandler { get; set; } +#pragma warning disable MCPEXP002 // CallToolHandler and CallToolWithAlternateHandler reference the experimental ResultOrAlternate seam /// /// Gets or sets the handler for requests. /// /// /// This handler is invoked when a client makes a call to a tool that isn't found in the collection. /// The handler should implement logic to execute the requested tool and return appropriate results. + /// Use instead if the tool may return an alternate result + /// for the caller to handle. /// - public McpRequestHandler? CallToolHandler { get; set; } + /// is already set. + public McpRequestHandler? CallToolHandler + { + get; + set + { + if (value is not null && CallToolWithAlternateHandler is not null) + { + throw new InvalidOperationException( + $"Cannot set {nameof(CallToolHandler)} when {nameof(CallToolWithAlternateHandler)} is already set. Only one call tool handler may be configured."); + } + + field = value; + } + } + + /// + /// Gets or sets the handler for requests with alternate result support. + /// + /// + /// + /// This handler is invoked when a client makes a call to a tool, allowing the tool to return either + /// a for immediate results or an alternate subtype. + /// + /// + /// This is a low-level full replacement for the ordinary tool-call pipeline. It cannot be set if + /// is already set, and it cannot be composed with ordinary + /// . + /// + /// + /// is already set. + [Experimental(Experimentals.Extensibility_DiagnosticId, UrlFormat = Experimentals.Extensibility_Url)] + public McpRequestHandler>? CallToolWithAlternateHandler + { + get; + set + { + if (value is not null && CallToolHandler is not null) + { + throw new InvalidOperationException( + $"Cannot set {nameof(CallToolWithAlternateHandler)} when {nameof(CallToolHandler)} is already set. Only one call tool handler may be configured."); + } + + field = value; + } + } +#pragma warning restore MCPEXP002 /// /// Gets or sets the handler for requests. @@ -141,6 +191,60 @@ public sealed class McpServerHandlers /// public McpRequestHandler? UnsubscribeFromResourcesHandler { get; set; } + /// + /// Gets or sets the handler for requests (SEP-2575). + /// + /// + /// + /// subscriptions/listen is a long-lived request introduced by the 2026-07-28 protocol revision. The + /// held-open response is a solicited server-to-client stream: the server first acknowledges which + /// subscriptions it will honor and then streams matching notifications until the request is cancelled. + /// Setting this handler lets a server author own that stream directly to implement custom subscription + /// kinds, application-driven resources/updated delivery, or subscriptions backed by their own event + /// source. It is especially useful for stateless Streamable HTTP, where unsolicited notifications are + /// dropped (there is no session-wide channel) but the listen request's response stream can still carry + /// notifications for the duration of the request. + /// + /// + /// This is a full replacement for the built-in subscriptions/listen handler. When set, the + /// SDK does not track the subscription, does not send the acknowledgement, and does not perform any + /// automatic */list_changed fan-out for the request; the handler is solely responsible for the + /// entire lifetime of the stream. The SDK still enforces protocol-version gating: the handler is only + /// reached when the negotiated protocol revision is 2026-07-28 or later, and is otherwise rejected with + /// . + /// + /// + /// An implementation of this handler is responsible for: + /// + /// + /// + /// Sending exactly one before any + /// subscription events, reporting only the filters it actually honors. Advertised server capabilities must + /// match what the handler will actually deliver. + /// + /// + /// Tagging every streamed notification with the listen request id under + /// _meta[] so clients sharing a channel can demultiplex it. + /// + /// + /// Remaining active for the subscription lifetime and cleaning up when the supplied + /// is cancelled (client disconnect on HTTP, or + /// notifications/cancelled on stdio). + /// + /// + /// Returning when it deliberately completes the stream. + /// + /// + /// + /// Notifications are sent through the request's server (for example request.Server.SendMessageAsync), + /// which routes them over the request's own response stream. For extension filters not represented by + /// , the handler can inspect + /// request.JsonRpcRequest.Params. Application services and event buses can be resolved from + /// request.Services or captured by the handler delegate. + /// + /// + public McpRequestHandler? SubscriptionsListenHandler { get; set; } + /// /// Gets or sets the handler for requests. /// @@ -154,6 +258,7 @@ public sealed class McpServerHandlers /// at or above the specified level to the client as notifications/message notifications. /// /// + [Obsolete(Obsoletions.DeprecatedLogging_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public McpRequestHandler? SetLoggingLevelHandler { get; set; } /// Gets or sets notification handlers to register with the server. diff --git a/src/ModelContextProtocol.Core/Server/McpServerImpl.cs b/src/ModelContextProtocol.Core/Server/McpServerImpl.cs index 04d11e016..2ce838713 100644 --- a/src/ModelContextProtocol.Core/Server/McpServerImpl.cs +++ b/src/ModelContextProtocol.Core/Server/McpServerImpl.cs @@ -2,14 +2,16 @@ using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging.Abstractions; using ModelContextProtocol.Protocol; +using System.Collections.Concurrent; using System.Runtime.CompilerServices; using System.Text.Json; +using System.Text.Json.Nodes; using System.Text.Json.Serialization.Metadata; namespace ModelContextProtocol.Server; /// -#pragma warning disable MCPEXP002 +#pragma warning disable MCPEXP001, MCPEXP002 internal sealed partial class McpServerImpl : McpServer { internal static Implementation DefaultImplementation { get; } = new() @@ -25,8 +27,24 @@ internal sealed partial class McpServerImpl : McpServer private readonly NotificationHandlers _notificationHandlers; private readonly RequestHandlers _requestHandlers; private readonly McpSessionHandler _sessionHandler; + private readonly string[] _supportedProtocolVersions; + private readonly string[] _initializeHandshakeProtocolVersions; + private readonly string[] _perRequestMetadataProtocolVersions; private readonly SemaphoreSlim _disposeLock = new(1, 1); - private readonly McpTaskCancellationTokenProvider? _taskCancellationTokenProvider; + private readonly ConcurrentDictionary _mrtrContinuations = new(); + private readonly ConcurrentDictionary _mrtrContextsByRequestId = new(); + private static readonly string[] s_perRequestMetadataKeys = + [ + MetaKeys.ProtocolVersion, + MetaKeys.ClientInfo, + MetaKeys.ClientCapabilities, + MetaKeys.LogLevel, + ]; + + // Track MRTR handler tasks using the same inFlightCount + TCS pattern as + // McpSessionHandler.ProcessMessagesCoreAsync. Starts at 1 for DisposeAsync itself. + private int _mrtrInFlightCount = 1; + private readonly TaskCompletionSource _allMrtrHandlersCompleted = new(TaskCreationOptions.RunContinuationsAsynchronously); private ClientCapabilities? _clientCapabilities; private Implementation? _clientInfo; @@ -63,17 +81,14 @@ public McpServerImpl(ITransport transport, McpServerOptions options, ILoggerFact _sessionTransport = transport; ServerOptions = options; Services = serviceProvider; + _supportedProtocolVersions = GetConfiguredSupportedProtocolVersions(options.ProtocolVersion); + _initializeHandshakeProtocolVersions = [.. _supportedProtocolVersions.Where(McpProtocolVersions.SupportsInitializeHandshake)]; + _perRequestMetadataProtocolVersions = [.. _supportedProtocolVersions.Where(McpProtocolVersions.RequiresPerRequestMetadata)]; _serverOnlyEndpointName = $"Server ({options.ServerInfo?.Name ?? DefaultImplementation.Name} {options.ServerInfo?.Version ?? DefaultImplementation.Version})"; _endpointName = _serverOnlyEndpointName; _servicesScopePerRequest = options.ScopeRequests; _logger = loggerFactory?.CreateLogger() ?? NullLogger.Instance; - // Only allocate the cancellation token provider if a task store is configured - if (options.TaskStore is not null) - { - _taskCancellationTokenProvider = new McpTaskCancellationTokenProvider(); - } - _clientInfo = options.KnownClientInfo; _clientCapabilities = options.KnownClientCapabilities; UpdateEndpointNameWithClientInfo(); @@ -84,13 +99,16 @@ public McpServerImpl(ITransport transport, McpServerOptions options, ILoggerFact // Configure all request handlers based on the supplied options. ServerCapabilities = new(); ConfigureInitialize(options); + ConfigureDiscover(options); ConfigureTools(options); ConfigurePrompts(options); ConfigureResources(options); - ConfigureTasks(options); ConfigureLogging(options); ConfigureCompletion(options); + ConfigureSubscriptions(options); ConfigureExperimentalAndExtensions(options); + ConfigureMrtr(); + ConfigureCustomRequestHandlers(options); // Register any notification handlers that were provided. if (options.Handlers.NotificationHandlers is { } notificationHandlers) @@ -98,20 +116,13 @@ public McpServerImpl(ITransport transport, McpServerOptions options, ILoggerFact _notificationHandlers.RegisterRange(notificationHandlers); } - // In stateless mode, the server cannot send unsolicited notifications, - // so listChanged should not be advertised. - if (transport is StreamableHttpServerTransport { Stateless: true }) - { - if (ServerCapabilities.Tools is not null) - ServerCapabilities.Tools.ListChanged = null; - if (ServerCapabilities.Prompts is not null) - ServerCapabilities.Prompts.ListChanged = null; - if (ServerCapabilities.Resources is not null) - ServerCapabilities.Resources.ListChanged = null; - } - - // Now that everything has been configured, subscribe to any necessary notifications. - if (transport is not StreamableHttpServerTransport streamableHttpTransport || streamableHttpTransport.Stateless is false) + // A stateful session can push unsolicited list-changed notifications, so subscribe to the + // collection change events. A stateless HTTP server cannot push unsolicited notifications; whether it + // may still advertise the listChanged capability (over a custom subscriptions/listen stream to a + // 2026-07-28+ client) is decided per response in GetAdvertisedCapabilities rather than cleared here, + // because the same ServerCapabilities feeds both the legacy initialize handshake (which can never + // deliver it) and server/discover (which can, given a custom handler). + if (HasStatefulTransport()) { Register(ServerOptions.ToolCollection, NotificationMethods.ToolListChangedNotification); Register(ServerOptions.PromptCollection, NotificationMethods.PromptListChangedNotification); @@ -122,16 +133,20 @@ void Register(McpServerPrimitiveCollection? collection, { if (collection is not null) { - EventHandler changed = (sender, e) => _ = this.SendNotificationAsync(notificationMethod); + EventHandler changed = (sender, e) => _ = SendListChangedNotificationAsync(notificationMethod); collection.Changed += changed; _disposables.Add(() => collection.Changed -= changed); } } } - // And initialize the session. - var incomingMessageFilter = BuildMessageFilterPipeline(options.Filters.Message.IncomingFilters); - var outgoingMessageFilter = BuildMessageFilterPipeline(options.Filters.Message.OutgoingFilters); + // And initialize the session. The built-in protocol metadata filters run ahead of any + // user-supplied message filters. + var incomingMessageFilter = PrependMetaReadingFilter(BuildMessageFilterPipeline(options.Filters.Message.IncomingFilters)); + var outgoingMessageFilter = PrependServerInfoFilter( + BuildMessageFilterPipeline(options.Filters.Message.OutgoingFilters), + options.ServerInfo ?? DefaultImplementation); + _sessionHandler = new McpSessionHandler( isServer: true, _sessionTransport, @@ -143,15 +158,398 @@ void Register(McpServerPrimitiveCollection? collection, _logger); } + /// + /// Wraps so that, for every JSON-RPC request, a built-in filter first + /// synchronizes server-side state (, ) + /// from the per-request _meta values projected onto and + /// validates the per-request protocol version, before delegating to the user-supplied incoming filters. + /// + /// + /// Under the 2026-07-28 protocol revision (SEP-2575) there is no initialize handshake, so the protocol + /// version and client capabilities MUST be populated per-request. Client info is optional. Per-request client + /// capabilities and client info are consumed request-scoped by and are + /// not read from server-wide state by request handlers. The shared write below is + /// best-effort and used only to derive the session endpoint name for logging/telemetry. For initialize-handshake + /// clients the per-request values are absent and the built-in filter is a no-op (the values were captured during + /// the initialize handler). + /// + private JsonRpcMessageFilter PrependMetaReadingFilter(JsonRpcMessageFilter inner) + { + JsonRpcMessageFilter metaReadingFilter = next => async (message, cancellationToken) => + { + if (message is JsonRpcRequest { Method: RequestMethods.Initialize } initializeRequest) + { + ValidateInitializeRequestBoundary(initializeRequest); + } + else if (message is JsonRpcRequest request) + { + var context = request.Context; + bool endpointNameNeedsRefresh = false; + bool hasProtocolVersionMeta = HasMetaKey(request, MetaKeys.ProtocolVersion); + bool hasReservedPerRequestMeta = TryGetPerRequestMetadataKey(request, out var reservedPerRequestMetaKey); + + if (context?.ProtocolVersion is { } protocolVersion) + { + bool protocolVersionAlreadyEstablished = _negotiatedProtocolVersion is not null; + if (protocolVersionAlreadyEstablished) + { + SetNegotiatedProtocolVersion(protocolVersion); + } + + // Per SEP-2575, the server MUST reject any request whose per-request + // _meta/io.modelcontextprotocol/protocolVersion is not one of its supported versions + // with an UnsupportedProtocolVersionError (-32022) carrying the supported list. + if (!_supportedProtocolVersions.Contains(protocolVersion)) + { + var supportedVersions = + hasProtocolVersionMeta && _perRequestMetadataProtocolVersions.Length > 0 ? + _perRequestMetadataProtocolVersions : + _supportedProtocolVersions; + + throw new UnsupportedProtocolVersionException( + requested: protocolVersion, + supported: supportedVersions); + } + + if (McpProtocolVersions.RequiresPerRequestMetadata(protocolVersion)) + { + ValidateRequiredPerRequestMetadata( + protocolVersion, + hasProtocolVersionMeta, + context.ClientCapabilities is not null); + } + else if (McpProtocolVersions.SupportsInitializeHandshake(protocolVersion)) + { + if (_negotiatedProtocolVersion is null && hasProtocolVersionMeta) + { + throw new UnsupportedProtocolVersionException( + requested: protocolVersion, + supported: _perRequestMetadataProtocolVersions, + message: $"Protocol version '{protocolVersion}' requires the initialize handshake and cannot be selected through per-request metadata."); + } + + if (hasReservedPerRequestMeta) + { + ThrowReservedPerRequestMetadata(requestedProtocolVersion: protocolVersion, reservedPerRequestMetaKey); + } + } + + if (!protocolVersionAlreadyEstablished) + { + SetNegotiatedProtocolVersion(protocolVersion); + } + } + else if (_negotiatedProtocolVersion is null) + { + if (request.Method == RequestMethods.ServerDiscover) + { + throw new McpProtocolException( + $"The '{RequestMethods.ServerDiscover}' request requires per-request metadata declaring a supported protocol version.", + McpErrorCode.InvalidParams); + } + + if (hasReservedPerRequestMeta) + { + ThrowReservedPerRequestMetadata(requestedProtocolVersion: null, reservedPerRequestMetaKey); + } + } + else if (McpProtocolVersions.SupportsInitializeHandshake(_negotiatedProtocolVersion) && hasReservedPerRequestMeta) + { + ThrowReservedPerRequestMetadata(_negotiatedProtocolVersion, reservedPerRequestMetaKey); + } + + ValidateRequestMethodBoundary(request); + + if (context?.ClientInfo is { } clientInfo && + (_clientInfo is null || !string.Equals(_clientInfo.Name, clientInfo.Name, StringComparison.Ordinal) || + !string.Equals(_clientInfo.Version, clientInfo.Version, StringComparison.Ordinal))) + { + // This shared write is best-effort and used only to derive the session endpoint name for + // logging/telemetry. It is intentionally NOT read by request handlers on 2026-07-28+ sessions: + // DestinationBoundMcpServer resolves ClientInfo (and ClientCapabilities) request-scoped from + // the per-request _meta so concurrent requests never observe each other's values. Under a + // draft stateful session with differing per-request client info, the last writer wins here, + // which only affects the logged endpoint name and never the request-scoped values handlers see. + _clientInfo = clientInfo; + endpointNameNeedsRefresh = true; + } + + if (endpointNameNeedsRefresh) + { + UpdateEndpointNameWithClientInfo(); + _sessionHandler.EndpointName = _endpointName; + } + } + else if (message is JsonRpcNotification notification) + { + ValidateNotificationBoundary(notification); + } + + await next(message, cancellationToken).ConfigureAwait(false); + }; + + return next => metaReadingFilter(inner(next)); + } + + private static void ValidateRequiredPerRequestMetadata( + string protocolVersion, + bool hasProtocolVersionMeta, + bool hasClientCapabilitiesMeta) + { + if (!hasProtocolVersionMeta) + { + ThrowMissingPerRequestMetadata(protocolVersion, MetaKeys.ProtocolVersion); + } + + // clientInfo is optional: requests whose _meta omits it are served, not rejected. + + if (!hasClientCapabilitiesMeta) + { + ThrowMissingPerRequestMetadata(protocolVersion, MetaKeys.ClientCapabilities); + } + } + + private static void ThrowMissingPerRequestMetadata(string protocolVersion, string key) => + throw new McpProtocolException( + $"Requests using protocol version '{protocolVersion}' must include '_meta/{key}'.", + McpErrorCode.InvalidParams); + + private static void ThrowReservedPerRequestMetadata(string? requestedProtocolVersion, string key) => + throw new McpProtocolException( + requestedProtocolVersion is null + ? $"The reserved per-request metadata key '_meta/{key}' requires a protocol version that uses per-request metadata." + : $"The reserved per-request metadata key '_meta/{key}' is not valid with protocol version '{requestedProtocolVersion}'.", + McpErrorCode.InvalidRequest); + + private static bool TryGetPerRequestMetadataKey(JsonRpcRequest request, out string key) + { + foreach (var candidate in s_perRequestMetadataKeys) + { + if (HasMetaKey(request, candidate)) + { + key = candidate; + return true; + } + } + + key = ""; + return false; + } + + private static bool HasMetaKey(JsonRpcRequest request, string key) => + request.Params is JsonObject paramsObj && + paramsObj["_meta"] is JsonObject metaObj && + metaObj.ContainsKey(key); + + /// + /// Adds the server identity to every successful result on per-request-metadata protocol revisions. + /// The filter runs before application filters so they can inspect or intentionally remove the metadata. + /// + private JsonRpcMessageFilter PrependServerInfoFilter(JsonRpcMessageFilter inner, Implementation serverInfo) + { + JsonRpcMessageFilter serverInfoFilter = next => async (message, cancellationToken) => + { + if (message is JsonRpcResponse { Result: JsonObject result } && + McpProtocolVersions.RequiresPerRequestMetadata( + message.Context?.ProtocolVersion ?? _negotiatedProtocolVersion)) + { + if (result["_meta"] is not JsonObject meta) + { + meta = new JsonObject(); + result["_meta"] = meta; + } + + meta[MetaKeys.ServerInfo] = JsonSerializer.SerializeToNode( + serverInfo, + McpJsonUtilities.JsonContext.Default.Implementation); + } + + await next(message, cancellationToken).ConfigureAwait(false); + }; + + return next => serverInfoFilter(inner(next)); + } + + private void ValidateInitializeRequestBoundary(JsonRpcRequest request) + { + // Per-request-metadata revisions (SEP-2575) removed the initialize handshake entirely: + // the request is for a method the server does not implement on that revision. + if (McpProtocolVersions.RequiresPerRequestMetadata(request.Context?.ProtocolVersion)) + { + throw new McpProtocolException( + $"Method '{RequestMethods.Initialize}' is not available on protocol version '{request.Context?.ProtocolVersion}'. Use '{RequestMethods.ServerDiscover}' and per-request metadata instead.", + McpErrorCode.MethodNotFound); + } + + if (request.Context?.ProtocolVersion is { } protocolVersion && + !McpProtocolVersions.SupportsInitializeHandshake(protocolVersion)) + { + throw new UnsupportedProtocolVersionException( + requested: protocolVersion, + supported: _initializeHandshakeProtocolVersions, + message: $"Protocol version '{protocolVersion}' is not available through the initialize handshake."); + } + + if (TryGetPerRequestMetadataKey(request, out var key)) + { + ThrowReservedPerRequestMetadata(TryGetStringParam(request, "protocolVersion"), key); + } + } + + private static string? TryGetStringParam(JsonRpcRequest request, string propertyName) + { + if (request.Params is JsonObject paramsObj && + paramsObj[propertyName] is JsonValue value && + value.TryGetValue(out string? result)) + { + return result; + } + + return null; + } + + private static string[] GetConfiguredSupportedProtocolVersions(string? protocolVersion) + { + if (protocolVersion is null) + { + return McpProtocolVersions.SupportedProtocolVersions; + } + + if (!McpProtocolVersions.IsSupportedProtocolVersion(protocolVersion)) + { + throw new McpException( + $"Unsupported server protocol version '{protocolVersion}'. Supported protocol versions: " + + string.Join(", ", McpProtocolVersions.SupportedProtocolVersions) + "."); + } + + return [protocolVersion]; + } + + private void ValidateNotificationBoundary(JsonRpcNotification notification) + { + if (notification.Method == NotificationMethods.InitializedNotification && + McpProtocolVersions.RequiresPerRequestMetadata(notification.Context?.ProtocolVersion ?? _negotiatedProtocolVersion)) + { + throw new McpProtocolException( + $"The notification '{NotificationMethods.InitializedNotification}' is only valid after the initialize handshake.", + McpErrorCode.InvalidRequest); + } + } + + private void ValidateRequestMethodBoundary(JsonRpcRequest request) + { + bool usesPerRequestMetadata = IsJuly2026OrLaterProtocolRequest(request); + + if (!usesPerRequestMetadata && + request.Method is RequestMethods.SubscriptionsListen + or RequestMethods.ServerDiscover) + { + throw new McpProtocolException( + $"The method '{request.Method}' requires a newer protocol revision that supports per-request metadata; " + + $"the negotiated protocol version is '{NegotiatedProtocolVersion ?? "(none)"}'.", + McpErrorCode.MethodNotFound); + } + + if (usesPerRequestMetadata && + request.Method is RequestMethods.Ping or RequestMethods.LoggingSetLevel + or RequestMethods.ResourcesSubscribe or RequestMethods.ResourcesUnsubscribe) + { + var replacement = GetRemovedMethodReplacementHint(request.Method); + throw new McpProtocolException( + $"The method '{request.Method}' is not available on protocol version '{request.Context?.ProtocolVersion ?? NegotiatedProtocolVersion}'." + + (replacement is null ? "" : $" {replacement}"), + McpErrorCode.MethodNotFound); + } + } + + /// + /// Returns guidance on the per-request-metadata replacement for a method that SEP-2575 removed, + /// or when the method has no direct replacement. Surfaced in the + /// error so a client that still calls the legacy RPC + /// (for example resources/subscribe) learns how to migrate. + /// + private static string? GetRemovedMethodReplacementHint(string method) => method switch + { + RequestMethods.LoggingSetLevel => $"Use the per-request '_meta/{MetaKeys.LogLevel}' field instead.", + RequestMethods.ResourcesSubscribe or RequestMethods.ResourcesUnsubscribe => + $"Use '{RequestMethods.SubscriptionsListen}' with 'resourceSubscriptions' instead.", + _ => null, + }; + /// public override string? SessionId => _sessionTransport.SessionId; /// public override string? NegotiatedProtocolVersion => _negotiatedProtocolVersion; + /// + /// Records the negotiated MCP protocol version for the session. The version is established exactly + /// once: the initial -to-value transition is allowed (and racing requests that + /// select the same version are idempotent no-ops), but any later attempt to switch to a different + /// version throws. A single session MUST NOT change protocol versions, so a conflicting per-request + /// _meta protocol version (or Mcp-Protocol-Version header) is a client error rather than + /// something we silently overwrite. + /// + private void SetNegotiatedProtocolVersion(string protocolVersion) + { + string? previous = Interlocked.CompareExchange(ref _negotiatedProtocolVersion, protocolVersion, null); + if (previous is null) + { + // We won the initial null-to-value transition; publish it to the session handler for telemetry. + _sessionHandler.NegotiatedProtocolVersion = protocolVersion; + } + else if (!string.Equals(previous, protocolVersion, StringComparison.Ordinal)) + { + throw new McpProtocolException( + $"The negotiated protocol version cannot change within a session. " + + $"The session negotiated '{previous}', but a request specified '{protocolVersion}'.", + McpErrorCode.InvalidRequest); + } + } + /// public ServerCapabilities ServerCapabilities { get; } + /// + /// Returns the to advertise in a specific response, suppressing the + /// listChanged flags the server has no way to honor. + /// + /// + /// when the client this response targets can receive */list_changed + /// notifications over a subscriptions/listen stream. + /// + /// + /// A stateless HTTP server has no session-wide channel to push unsolicited */list_changed + /// notifications. It can only deliver them over a subscriptions/listen stream, which requires both + /// a 2026-07-28+ client (so the request is reachable at all) and a custom + /// to own that stream (the built-in stateless + /// handler grants no notifications). When neither the transport is stateful nor that stream can carry + /// them, the listChanged flags are dropped so the server never advertises a capability it cannot + /// deliver. Everything else (for example resources.subscribe) is preserved. + /// + private ServerCapabilities GetAdvertisedCapabilities(bool listenStreamCanDeliverListChanged) + { + if (HasStatefulTransport() || listenStreamCanDeliverListChanged) + { + return ServerCapabilities; + } + + // Copy onto a fresh instance so the shared ServerCapabilities keeps the authored listChanged flags; + // server/discover with a custom listen handler may still advertise them. + return new ServerCapabilities + { + Experimental = ServerCapabilities.Experimental, + Logging = ServerCapabilities.Logging, + Completions = ServerCapabilities.Completions, + Extensions = ServerCapabilities.Extensions, + Prompts = ServerCapabilities.Prompts is null ? null : new PromptsCapability { ListChanged = null }, + Resources = ServerCapabilities.Resources is { } resources + ? new ResourcesCapability { Subscribe = resources.Subscribe, ListChanged = null } + : null, + Tools = ServerCapabilities.Tools is null ? null : new ToolsCapability { ListChanged = null }, + }; + } + /// public override ClientCapabilities? ClientCapabilities => _clientCapabilities; @@ -165,6 +563,7 @@ void Register(McpServerPrimitiveCollection? collection, public override IServiceProvider? Services { get; } /// + [Obsolete(Obsoletions.DeprecatedLogging_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public override LoggingLevel? LoggingLevel => _loggingLevel?.Value; /// @@ -210,9 +609,34 @@ public override async ValueTask DisposeAsync() _disposed = true; - _taskCancellationTokenProvider?.Dispose(); + // Dispose the session handler - cancels message processing and waits for all + // in-flight request handlers (including retries in AwaitMrtrHandlerAsync) to complete. + // After this returns, no new requests can be processed and no new MRTR continuations + // can be created, so _mrtrContinuations is effectively frozen. _disposables.ForEach(d => d()); await _sessionHandler.DisposeAsync().ConfigureAwait(false); + + // Cancel all orphaned MRTR handlers still suspended in continuations (waiting for + // retries that will never arrive now that the session handler is disposed). + int cancelledCount = _mrtrContinuations.Count; + foreach (var continuation in _mrtrContinuations.Values) + { + continuation.CancelHandler(); + } + + if (cancelledCount > 0) + { + MrtrContinuationsCancelled(cancelledCount); + } + + // Wait for all MRTR handler tasks to complete using the same inFlightCount + TCS + // pattern as McpSessionHandler.ProcessMessagesCoreAsync. The count started at 1 + // (for DisposeAsync itself); decrementing it here triggers the drain if handlers + // are still in flight. ObserveHandlerCompletionAsync decrements for each handler. + if (Interlocked.Decrement(ref _mrtrInFlightCount) != 0) + { + await _allMrtrHandlersCompleted.Task.ConfigureAwait(false); + } } private void ConfigureInitialize(McpServerOptions options) @@ -227,82 +651,410 @@ private void ConfigureInitialize(McpServerOptions options) UpdateEndpointNameWithClientInfo(); _sessionHandler.EndpointName = _endpointName; - // Negotiate a protocol version. If the server options provide one, use that. - // Otherwise, try to use whatever the client requested as long as it's supported. - // If it's not supported, fall back to the latest supported version. + // Negotiate an initialize-handshake protocol version. initialize is not available in the 2026-07-28 + // and later protocol revisions, so those versions must use server/discover with + // per-request _meta instead. string? protocolVersion = options.ProtocolVersion; - protocolVersion ??= request?.ProtocolVersion is string clientProtocolVersion && McpSessionHandler.SupportedProtocolVersions.Contains(clientProtocolVersion) ? - clientProtocolVersion : - McpSessionHandler.LatestProtocolVersion; + if (protocolVersion is { } configuredProtocolVersion && + McpProtocolVersions.IsJuly2026OrLaterProtocolVersion(configuredProtocolVersion)) + { + throw new UnsupportedProtocolVersionException( + configuredProtocolVersion, + _initializeHandshakeProtocolVersions, + $"Protocol version '{configuredProtocolVersion}' is not available through the initialize handshake."); + } + + if (protocolVersion is null) + { + if (request?.ProtocolVersion is string clientProtocolVersion) + { + if (McpProtocolVersions.IsJuly2026OrLaterProtocolVersion(clientProtocolVersion)) + { + throw new UnsupportedProtocolVersionException( + clientProtocolVersion, + _initializeHandshakeProtocolVersions, + $"Protocol version '{clientProtocolVersion}' is not available through the initialize handshake."); + } + + protocolVersion = McpProtocolVersions.SupportsInitializeHandshake(clientProtocolVersion) ? + clientProtocolVersion : + McpProtocolVersions.November2025ProtocolVersion; + } + else + { + protocolVersion = McpProtocolVersions.November2025ProtocolVersion; + } + } - _negotiatedProtocolVersion = protocolVersion; + string negotiatedProtocolVersion = protocolVersion ?? McpProtocolVersions.November2025ProtocolVersion; - // Update session handler with the negotiated protocol version for telemetry - _sessionHandler.NegotiatedProtocolVersion = protocolVersion; + // The initialize handshake is authoritative: it may supersede a protocol version + // a prior server/discover probe established on the same connection (the dual-path + // fallback path a permissive client takes against an unknown server). Unlike the + // per-request 2026-07-28 version - which SetNegotiatedProtocolVersion locks once negotiated - + // initialize force-sets the version. + _negotiatedProtocolVersion = negotiatedProtocolVersion; + _sessionHandler.NegotiatedProtocolVersion = negotiatedProtocolVersion; return new InitializeResult { - ProtocolVersion = protocolVersion, + ProtocolVersion = negotiatedProtocolVersion, Instructions = options.ServerInstructions, ServerInfo = options.ServerInfo ?? DefaultImplementation, - Capabilities = ServerCapabilities ?? new(), + + // The initialize handshake only serves pre-2026-07-28 clients, which cannot open a + // subscriptions/listen stream, so a stateless server has no way to deliver list-changed + // notifications to them regardless of any custom handler. + Capabilities = GetAdvertisedCapabilities(listenStreamCanDeliverListChanged: false), + + // resultType is a 2026-07-28 result field. The initialize handshake is only available on + // 2025-11-25 and earlier revisions (2026-07-28+ negotiate via server/discover and throw + // above), so InitializeResult must never carry resultType (issue #1721). }; }, McpJsonUtilities.JsonContext.Default.InitializeRequestParams, McpJsonUtilities.JsonContext.Default.InitializeResult); } - private void ConfigureCompletion(McpServerOptions options) + /// + /// Registers the server/discover request handler introduced by the 2026-07-28 protocol revision (SEP-2575). + /// + /// + /// The handler is registered unconditionally so requests can be routed to the protocol boundary filters. Successful + /// server/discover responses advertise only protocol versions available through per-request metadata; versions + /// that require the initialize handshake are negotiated through initialize instead. + /// + private void ConfigureDiscover(McpServerOptions options) { - var completeHandler = options.Handlers.CompleteHandler; - var completionsCapability = options.Capabilities?.Completions; - - // Build completion value lookups from prompt/resource collections' [AllowedValues]-attributed parameters. - Dictionary>? promptCompletions = BuildAllowedValueCompletions(options.PromptCollection); - Dictionary>? resourceCompletions = BuildAllowedValueCompletions(options.ResourceCollection); - bool hasCollectionCompletions = promptCompletions is not null || resourceCompletions is not null; + _requestHandlers.Set(RequestMethods.ServerDiscover, + (request, _, _) => + { + return new ValueTask(new DiscoverResult + { + SupportedVersions = [.. _perRequestMetadataProtocolVersions], + + // server/discover only serves 2026-07-28+ clients, which can open a subscriptions/listen + // stream. A stateless server can therefore still deliver list-changed notifications if the + // author supplied a custom handler to own that stream (the built-in stateless handler + // grants nothing, so it cannot). + Capabilities = GetAdvertisedCapabilities( + listenStreamCanDeliverListChanged: options.Handlers.SubscriptionsListenHandler is not null), + Instructions = options.ServerInstructions, + // Spec PR #2855 makes ttlMs and cacheScope required on DiscoverResult. Default to + // the safest values (immediately stale, not shareable) so existing servers keep + // their "do not cache" behavior while satisfying the wire requirement. + TimeToLive = TimeSpan.Zero, + CacheScope = CacheScope.Private, + ResultType = "complete", + }); + }, + McpJsonUtilities.JsonContext.Default.DiscoverRequestParams, + McpJsonUtilities.JsonContext.Default.DiscoverResult); + } - if (completeHandler is null && completionsCapability is null && !hasCollectionCompletions) + /// + /// Registers the subscriptions/listen request handler introduced by the 2026-07-28 protocol revision (SEP-2575). + /// + /// + /// + /// The handler opens a long-lived response stream (over the per-request + /// for HTTP, or the shared STDIO channel) that first sends + /// reporting which subscriptions the + /// server agreed to honor, and then streams matching notifications until the request is cancelled. + /// + /// + /// Subscription-bound notifications carry the listen request's id in their + /// _meta/io.modelcontextprotocol/subscriptionId field per SEP-2575 so clients can demultiplex. + /// + /// + /// A server author may supply a custom to take + /// over the stream entirely; see the design notes at the top of this method for the behavior. + /// + /// + private void ConfigureSubscriptions(McpServerOptions options) + { + // Design decision 1 of issue #1662 (replacement vs. additive handler): a custom + // SubscriptionsListenHandler is a FULL REPLACEMENT for the built-in subscriptions/listen handler, not + // an additive/composed one. When one is set, that handler exclusively owns the stream: the SDK does + // not track the subscription in _activeSubscriptions, does not send the acknowledgement, and performs + // no automatic */list_changed fan-out for the request. This keeps the SEP-2575 contract trivial to + // honor (exactly one acknowledgement, no duplicate delivery) and mirrors the existing low-level + // replacement handlers such as CallToolWithAlternateHandler. An additive design was rejected because + // two writers on one stream create ambiguity over who sends the single acknowledgement, force the two + // lifetimes to be coordinated, and risk double-tagging the subscription id. + if (options.Handlers.SubscriptionsListenHandler is { } subscriptionsListenHandler) { + // Route the custom handler through SetHandler so it receives the same DestinationBoundMcpServer as + // every other typed handler. That server sends notifications over this request's own response + // stream (its RelatedTransport), which is what lets the handler stream even under stateless + // Streamable HTTP, where the held-open POST response is the only solicited server-to-client + // channel (the core scenario of issue #1662). Going through SetHandler also applies the standard + // 2026-07-28 resultType stamping and provides the request-scoped service provider via + // request.Services. + SetHandler(RequestMethods.SubscriptionsListen, + (request, cancellationToken) => + { + // Protocol-version gating stays in the SDK rather than the custom handler, so a custom + // handler can never be reached on a revision that predates SEP-2575. subscriptions/listen + // is a 2026-07-28 feature; on older negotiated revisions it is rejected as an unknown + // method, exactly as the built-in handler below does. + if (!IsJuly2026OrLaterProtocolRequest(request.JsonRpcRequest)) + { + throw new McpProtocolException( + $"The method '{RequestMethods.SubscriptionsListen}' requires a newer protocol revision that supports per-request subscriptions; " + + $"the negotiated protocol version is '{NegotiatedProtocolVersion ?? "(none)"}'.", + McpErrorCode.MethodNotFound); + } + + // Notifications is 'required', but that only enforces presence during deserialization, + // not non-nullness: a '{"notifications": null}' payload produces a non-null params object + // with a null Notifications (DefaultOptions does not set RespectNullableAnnotations). + // Normalize null to empty so a custom handler can dereference request.Params.Notifications + // without an NRE, matching the built-in handler's request?.Notifications guard below. + request.Params ??= new SubscriptionsListenRequestParams { Notifications = new() }; + request.Params.Notifications ??= new SubscriptionsListenNotifications(); + + return subscriptionsListenHandler(request, cancellationToken); + }, + McpJsonUtilities.JsonContext.Default.SubscriptionsListenRequestParams, + McpJsonUtilities.JsonContext.Default.EmptyResult); return; } - completeHandler ??= (static async (_, __) => new CompleteResult()); - - // Augment the completion handler with allowed values from prompt/resource collections. - if (hasCollectionCompletions) - { - var originalCompleteHandler = completeHandler; - completeHandler = async (request, cancellationToken) => + _requestHandlers.Set(RequestMethods.SubscriptionsListen, + async (request, jsonRpcRequest, cancellationToken) => { - CompleteResult result = await originalCompleteHandler(request, cancellationToken).ConfigureAwait(false); + if (!IsJuly2026OrLaterProtocolRequest(jsonRpcRequest)) + { + throw new McpProtocolException( + $"The method '{RequestMethods.SubscriptionsListen}' requires a newer protocol revision that supports per-request subscriptions; " + + $"the negotiated protocol version is '{NegotiatedProtocolVersion ?? "(none)"}'.", + McpErrorCode.MethodNotFound); + } - string[]? allowedValues = null; - switch (request.Params?.Ref) + var requested = request?.Notifications ?? new SubscriptionsListenNotifications(); + + // A stateless session (Streamable HTTP with no session) cannot deliver out-of-band + // notifications: each request is isolated and nothing outlives it to push later list/resource + // changes back to the client (tracked by #1662). Rather than hold the POST open forever only + // to deliver nothing - pinning the connection and its request scope - acknowledge the listen + // request granting no notifications and complete immediately. This runs after protocol + // negotiation, so it is not an initialize-handshake-server signal and never triggers a client fallback to the + // initialize handshake. + if (!HasStatefulTransport()) { - case PromptReference pr when promptCompletions is not null: - if (promptCompletions.TryGetValue(pr.Name, out var promptParams)) - { - promptParams.TryGetValue(request.Params.Argument.Name, out allowedValues); - } - break; + var statelessSubscription = new ActiveSubscription( + jsonRpcRequest.Id, + new SubscriptionsListenNotifications(), + jsonRpcRequest.Context?.RelatedTransport); - case ResourceTemplateReference rtr when resourceCompletions is not null: - if (rtr.Uri is not null && resourceCompletions.TryGetValue(rtr.Uri, out var resourceParams)) - { - resourceParams.TryGetValue(request.Params.Argument.Name, out allowedValues); - } - break; + await SendSubscriptionAckAsync(statelessSubscription, cancellationToken).ConfigureAwait(false); + + return EmptyResult.Instance; } - if (allowedValues is not null) + // Filter the requested notifications against what the server actually supports. + var granted = new SubscriptionsListenNotifications { - string partialValue = request.Params!.Argument.Value; - foreach (var v in allowedValues) - { - if (v.StartsWith(partialValue, StringComparison.OrdinalIgnoreCase)) - { - result.Completion.Values.Add(v); + ToolsListChanged = requested.ToolsListChanged == true && ServerCapabilities?.Tools?.ListChanged == true ? true : null, + PromptsListChanged = requested.PromptsListChanged == true && ServerCapabilities?.Prompts?.ListChanged == true ? true : null, + ResourcesListChanged = requested.ResourcesListChanged == true && ServerCapabilities?.Resources?.ListChanged == true ? true : null, + ResourceSubscriptions = requested.ResourceSubscriptions is { Count: > 0 } subs && ServerCapabilities?.Resources?.Subscribe == true + ? new List(subs) + : null, + }; + + // Track this subscription so list-changed notifications can be fanned out to it, tagged with + // the right subscriptionId, and routed back over the stream this request opened. + var subscription = new ActiveSubscription( + jsonRpcRequest.Id, + granted, + jsonRpcRequest.Context?.RelatedTransport); + _activeSubscriptions[jsonRpcRequest.Id] = subscription; + + try + { + // Send the acknowledgement notification first, as required by SEP-2575. Like every other + // notification delivered on the subscription it is routed back over this request's own + // stream and tagged with the subscription id so shared-channel clients can demultiplex it. + await SendSubscriptionAckAsync(subscription, cancellationToken).ConfigureAwait(false); + + // Keep the subscription open until the request is cancelled (client disconnect on HTTP, + // or notifications/cancelled on STDIO). + var tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + using var registration = cancellationToken.Register(static state => ((TaskCompletionSource)state!).TrySetResult(true), tcs); + await tcs.Task.ConfigureAwait(false); + } + finally + { + _activeSubscriptions.TryRemove(jsonRpcRequest.Id, out _); + } + + return EmptyResult.Instance; + }, + McpJsonUtilities.JsonContext.Default.SubscriptionsListenRequestParams, + McpJsonUtilities.JsonContext.Default.EmptyResult); + } + + /// Tracks an active subscriptions/listen subscription for notification fan-out. + /// The id of the subscriptions/listen request, reused as the SEP-2575 subscription id. + /// The notification types the server agreed to deliver on this subscription. + /// + /// The transport the subscriptions/listen request arrived on. For Streamable HTTP this is the + /// per-request response stream the subscription must be delivered on; for stdio it is , + /// so notifications fall back to the shared session channel. + /// + private sealed record ActiveSubscription(RequestId Id, SubscriptionsListenNotifications Granted, ITransport? RelatedTransport); + + private readonly ConcurrentDictionary _activeSubscriptions = new(); + + /// + /// Delivers a */list_changed notification triggered by a server-side collection change. + /// + /// + /// Pre-SEP-2575 clients do not open subscriptions/listen streams, so they keep receiving a single + /// session-wide broadcast. Clients on the 2026-07-28 or later revision instead receive only the change notifications they explicitly + /// requested, each routed back over the originating subscription stream and tagged with its id; the server + /// MUST NOT send such a client notification types it never subscribed to. + /// + private async Task SendListChangedNotificationAsync(string notificationMethod) + { + // Initialize-handshake clients never open a subscriptions/listen stream, so they keep the session-wide broadcast. + // subscriptions/listen is a SEP-2575 feature, so clients on the 2026-07-28 or later revision instead get + // a fan-out limited to the notification types they explicitly subscribed to. + if (!IsJuly2026OrLaterProtocol()) + { + await this.SendNotificationAsync(notificationMethod).ConfigureAwait(false); + return; + } + + foreach (var subscription in _activeSubscriptions.Values) + { + if (!GrantsListChanged(subscription.Granted, notificationMethod)) + { + continue; + } + + try + { + await SendSubscriptionNotificationAsync(subscription, notificationMethod, paramsNode: null, CancellationToken.None).ConfigureAwait(false); + } + catch (Exception ex) + { + // A single closed or faulted subscription stream must not prevent fan-out to the others. + SubscriptionNotificationFailed(notificationMethod, subscription.Id.ToString(), ex); + } + } + } + + /// + /// Sends over 's stream, tagging it with the + /// SEP-2575 _meta subscription id so clients sharing a channel (notably stdio) can demultiplex it. + /// + private Task SendSubscriptionNotificationAsync(ActiveSubscription subscription, string method, JsonNode? paramsNode, CancellationToken cancellationToken) + { + var paramsObject = paramsNode as JsonObject ?? new JsonObject(); + if (paramsObject["_meta"] is not JsonObject meta) + { + meta = new JsonObject(); + paramsObject["_meta"] = meta; + } + + meta[MetaKeys.SubscriptionId] = subscription.Id.Id switch + { + string stringId => JsonValue.Create(stringId), + long longId => JsonValue.Create(longId), + _ => null, + }; + + var notification = new JsonRpcNotification + { + Method = method, + Params = paramsObject, + Context = new JsonRpcMessageContext { RelatedTransport = subscription.RelatedTransport }, + }; + + return SendMessageAsync(notification, cancellationToken); + } + + /// + /// Sends the SEP-2575 subscriptions/acknowledged notification for a subscription, carrying the + /// notification types the server agreed to deliver. Routed back over the subscription's own stream and + /// tagged with its id like every other subscription notification. + /// + private Task SendSubscriptionAckAsync(ActiveSubscription subscription, CancellationToken cancellationToken) + { + var ackParams = JsonSerializer.SerializeToNode( + new SubscriptionsAcknowledgedNotificationParams { Notifications = subscription.Granted }, + McpJsonUtilities.JsonContext.Default.SubscriptionsAcknowledgedNotificationParams); + + return SendSubscriptionNotificationAsync( + subscription, + NotificationMethods.SubscriptionsAcknowledgedNotification, + ackParams, + cancellationToken); + } + + /// Maps a */list_changed method to the subscription filter flag that enables it. + private static bool GrantsListChanged(SubscriptionsListenNotifications granted, string method) => method switch + { + NotificationMethods.ToolListChangedNotification => granted.ToolsListChanged == true, + NotificationMethods.PromptListChangedNotification => granted.PromptsListChanged == true, + NotificationMethods.ResourceListChangedNotification => granted.ResourcesListChanged == true, + _ => false, + }; + + private void ConfigureCompletion(McpServerOptions options) + { + var completeHandler = options.Handlers.CompleteHandler; + var completionsCapability = options.Capabilities?.Completions; + + // Build completion value lookups from prompt/resource collections' [AllowedValues]-attributed parameters. + Dictionary>? promptCompletions = BuildAllowedValueCompletions(options.PromptCollection); + Dictionary>? resourceCompletions = BuildAllowedValueCompletions(options.ResourceCollection); + bool hasCollectionCompletions = promptCompletions is not null || resourceCompletions is not null; + + if (completeHandler is null && completionsCapability is null && !hasCollectionCompletions) + { + return; + } + + completeHandler ??= (static async (_, __) => new CompleteResult()); + + // Augment the completion handler with allowed values from prompt/resource collections. + if (hasCollectionCompletions) + { + var originalCompleteHandler = completeHandler; + completeHandler = async (request, cancellationToken) => + { + CompleteResult result = await originalCompleteHandler(request, cancellationToken).ConfigureAwait(false); + + string[]? allowedValues = null; + switch (request.Params?.Ref) + { + case PromptReference pr when promptCompletions is not null: + if (promptCompletions.TryGetValue(pr.Name, out var promptParams)) + { + promptParams.TryGetValue(request.Params.Argument.Name, out allowedValues); + } + break; + + case ResourceTemplateReference rtr when resourceCompletions is not null: + if (rtr.Uri is not null && resourceCompletions.TryGetValue(rtr.Uri, out var resourceParams)) + { + resourceParams.TryGetValue(request.Params.Argument.Name, out allowedValues); + } + break; + } + + if (allowedValues is not null) + { + string partialValue = request.Params!.Argument.Value; + foreach (var v in allowedValues) + { + if (v.StartsWith(partialValue, StringComparison.OrdinalIgnoreCase)) + { + result.Completion.Values.Add(v); } } @@ -400,6 +1152,49 @@ private void ConfigureExperimentalAndExtensions(McpServerOptions options) ServerCapabilities.Extensions = options.Capabilities?.Extensions; } + private void ConfigureCustomRequestHandlers(McpServerOptions options) + { +#pragma warning disable MCPEXP002 + if (options.RequestHandlers is not { Count: > 0 } customHandlers) + { + return; + } + + foreach (var entry in customHandlers) + { + if (string.IsNullOrEmpty(entry.Method)) + { + throw new InvalidOperationException( + $"A custom request handler registered through {nameof(McpServerOptions)}.{nameof(McpServerOptions.RequestHandlers)} has a null or empty {nameof(McpServerRequestHandler.Method)}."); + } + + if (entry.RoutingNameParameter is not null && string.IsNullOrWhiteSpace(entry.RoutingNameParameter)) + { + throw new InvalidOperationException( + $"A custom request handler registered through {nameof(McpServerOptions)}.{nameof(McpServerOptions.RequestHandlers)} has an empty {nameof(McpServerRequestHandler.RoutingNameParameter)}."); + } + + // Custom handlers are registered after all built-in handlers, so a method already present + // belongs to a built-in method (e.g. initialize, tools/call) or an earlier custom handler. + // Silently overwriting it would bypass the built-in handler's filters and protocol gating, + // so reject the collision instead. + if (_requestHandlers.ContainsKey(entry.Method)) + { + throw new InvalidOperationException( + $"A custom request handler registered through {nameof(McpServerOptions)}.{nameof(McpServerOptions.RequestHandlers)} " + + $"uses the method '{entry.Method}', which is already handled by the server. Custom handlers cannot replace built-in methods or other custom handlers."); + } + + SetRawHandler(entry.Method, entry.Handler); + } +#pragma warning restore MCPEXP002 + } + + private void SetRawHandler(string method, Func> handler) + { + _requestHandlers[method] = (request, ct) => handler(request, ct).AsTask(); + } + private void ConfigureResources(McpServerOptions options) { var listResourcesHandler = options.Handlers.ListResourcesHandler; @@ -421,7 +1216,13 @@ subscribeHandler is null && unsubscribeHandler is null && resources is null && listResourcesHandler ??= (static async (_, __) => new ListResourcesResult()); listResourceTemplatesHandler ??= (static async (_, __) => new ListResourceTemplatesResult()); - readResourceHandler ??= (static async (request, _) => throw new McpProtocolException($"Unknown resource URI: '{request.Params?.Uri}'", McpErrorCode.ResourceNotFound)); + readResourceHandler ??= (static async (request, _) => + { + var errorCode = McpProtocolVersions.UseInvalidParamsForMissingResource(request.Server.NegotiatedProtocolVersion) + ? McpErrorCode.InvalidParams + : McpErrorCode.ResourceNotFound; + throw new McpProtocolException($"Unknown resource URI: '{request.Params?.Uri}'", errorCode); + }); subscribeHandler ??= (static async (_, __) => new EmptyResult()); unsubscribeHandler ??= (static async (_, __) => new EmptyResult()); var listChanged = resourcesCapability?.ListChanged; @@ -659,14 +1460,16 @@ await originalListPromptsHandler(request, cancellationToken).ConfigureAwait(fals McpJsonUtilities.JsonContext.Default.GetPromptResult); } +#pragma warning disable MCPEXP002 // tool dispatch wires up the experimental alternate call-tool handler and filters private void ConfigureTools(McpServerOptions options) { var listToolsHandler = options.Handlers.ListToolsHandler; var callToolHandler = options.Handlers.CallToolHandler; + var callToolWithAlternateHandler = options.Handlers.CallToolWithAlternateHandler; var tools = options.ToolCollection; var toolsCapability = options.Capabilities?.Tools; - if (listToolsHandler is null && callToolHandler is null && tools is null && + if (listToolsHandler is null && callToolHandler is null && callToolWithAlternateHandler is null && tools is null && toolsCapability is null) { return; @@ -675,10 +1478,21 @@ private void ConfigureTools(McpServerOptions options) ServerCapabilities.Tools = new(); listToolsHandler ??= (static async (_, __) => new ListToolsResult()); - callToolHandler ??= (static async (request, _) => throw new McpProtocolException($"Unknown tool: '{request.Params?.Name}'", McpErrorCode.InvalidParams)); var listChanged = toolsCapability?.ListChanged; - // Handle tools provided via DI by augmenting the handlers to incorporate them. + var callToolFilters = options.Filters.Request.CallToolFilters; + var callToolWithAlternateFilters = options.Filters.Request.CallToolWithAlternateFilters; + + if (callToolWithAlternateHandler is not null && callToolFilters.Count > 0) + { + throw new InvalidOperationException( + $"Cannot apply {nameof(McpRequestFilters.CallToolFilters)} when an explicit " + + $"{nameof(McpServerHandlers.CallToolWithAlternateHandler)} is configured. The alternate handler " + + $"replaces the ordinary tool-call pipeline. Move the behavior to " + + $"{nameof(McpRequestFilters.CallToolWithAlternateFilters)} or remove the explicit alternate handler."); + } + + // Handle tools provided via DI by augmenting the list handler. if (tools is not null) { var originalListToolsHandler = listToolsHandler; @@ -690,104 +1504,83 @@ await originalListToolsHandler(request, cancellationToken).ConfigureAwait(false) if (request.Params?.Cursor is null) { + // SEP-2106 wire shaping: clients on protocol versions older than + // 2026-07-28 require outputSchema.type == "object", so the natural + // schema is reshaped before emission (type:["object","null"] normalized + // to "object", any other non-object schema wrapped in + // {"type":"object","properties":{"result":}}). Clients on + // 2026-07-28+ receive the natural JSON Schema 2020-12 document stored + // on Tool.OutputSchema. Only AIFunctionMcpServerTool tools go through + // reshaping; custom McpServerTool subclasses build their Tool directly + // and pass through unchanged at every protocol version. + bool useNaturalSchemas = McpSessionHandler.SupportsNaturalOutputSchemas(request.Server.NegotiatedProtocolVersion); foreach (var t in tools) { - result.Tools.Add(t.ProtocolTool); + Tool wireTool = useNaturalSchemas || t is not AIFunctionMcpServerTool aiFunctionTool + ? t.ProtocolTool + : aiFunctionTool.BuildLegacyWireProtocolTool(); + result.Tools.Add(wireTool); } } return result; }; - var originalCallToolHandler = callToolHandler; - var taskStore = options.TaskStore; - var sendNotifications = options.SendTaskStatusNotifications; - callToolHandler = async (request, cancellationToken) => - { - if (request.MatchedPrimitive is McpServerTool tool) - { - var taskSupport = tool.ProtocolTool.Execution?.TaskSupport ?? ToolTaskSupport.Forbidden; - - // Check if this is a task-augmented request - if (request.Params?.Task is { } taskMetadata) - { - // Validate tool-level task support - if (taskSupport is ToolTaskSupport.Forbidden) - { - throw new McpProtocolException( - $"Tool '{tool.ProtocolTool.Name}' does not support task-augmented execution.", - McpErrorCode.InvalidParams); - } + listChanged = true; + } - // Task augmentation requested - return CreateTaskResult - return await ExecuteToolAsTaskAsync(tool, request, taskMetadata, taskStore, sendNotifications, cancellationToken).ConfigureAwait(false); - } + listToolsHandler = BuildFilterPipeline(listToolsHandler, options.Filters.Request.ListToolsFilters); - // Validate that required task support is satisfied - if (taskSupport is ToolTaskSupport.Required) + // An explicit alternate handler replaces the ordinary tool-call pipeline. + if (callToolWithAlternateHandler is not null) + { + // Augment with DI tools. + if (tools is not null) + { + var originalHandler = callToolWithAlternateHandler; + callToolWithAlternateHandler = (request, cancellationToken) => + { + MatchTool(request, tools); + if (request.MatchedPrimitive is McpServerTool tool) { - throw new McpProtocolException( - $"Tool '{tool.ProtocolTool.Name}' requires task-augmented execution. " + - "Include a 'task' parameter with the request.", - McpErrorCode.InvalidParams); + return InvokeToolWithAlternate(tool, request, cancellationToken); } - // Normal synchronous execution - return await tool.InvokeAsync(request, cancellationToken).ConfigureAwait(false); - } - - return await originalCallToolHandler(request, cancellationToken).ConfigureAwait(false); - }; + return originalHandler(request, cancellationToken); + }; + } - listChanged = true; + callToolWithAlternateHandler = BuildInvocationFilterPipeline( + callToolWithAlternateHandler, + callToolWithAlternateFilters, + BuildInitialAlternateToolFilter(tools)); } + else + { + callToolHandler ??= (static async (request, _) => throw new McpProtocolException($"Unknown tool: '{request.Params?.Name}'", McpErrorCode.InvalidParams)); - listToolsHandler = BuildFilterPipeline(listToolsHandler, options.Filters.Request.ListToolsFilters); - callToolHandler = BuildFilterPipeline(callToolHandler, options.Filters.Request.CallToolFilters, handler => - async (request, cancellationToken) => + // Augment with DI tools. + if (tools is not null) { - // Initial handler that sets MatchedPrimitive - if (request.Params?.Name is { } toolName && tools is not null && - tools.TryGetPrimitive(toolName, out var tool)) - { - request.MatchedPrimitive = tool; - } - - try + var originalHandler = callToolHandler; + callToolHandler = (request, cancellationToken) => { - var result = await handler(request, cancellationToken).ConfigureAwait(false); - - // Don't log here for task-augmented calls; logging happens asynchronously - // in ExecuteToolAsTaskAsync when the tool actually completes. - if (result.Task is null) + if (request.MatchedPrimitive is McpServerTool tool) { - ToolCallCompleted(request.Params?.Name ?? string.Empty, result.IsError is true); + return tool.InvokeAsync(request, cancellationToken); } - return result; - } - catch (Exception e) - { - ToolCallError(request.Params?.Name ?? string.Empty, e); - - if ((e is OperationCanceledException && cancellationToken.IsCancellationRequested) || e is McpProtocolException) - { - throw; - } + return originalHandler(request, cancellationToken); + }; + } - return new() - { - IsError = true, - Content = [new TextContentBlock - { - Text = e is McpException ? - $"An error occurred invoking '{request.Params?.Name}': {e.Message}" : - $"An error occurred invoking '{request.Params?.Name}'.", - }], - }; - } - }); + callToolHandler = BuildFilterPipeline(callToolHandler, callToolFilters); + callToolWithAlternateHandler = BuildComposedCallToolHandler( + callToolHandler, + callToolWithAlternateFilters, + tools); + } ServerCapabilities.Tools.ListChanged = listChanged; SetHandler( @@ -796,149 +1589,172 @@ await originalListToolsHandler(request, cancellationToken).ConfigureAwait(false) McpJsonUtilities.JsonContext.Default.ListToolsRequestParams, McpJsonUtilities.JsonContext.Default.ListToolsResult); - SetHandler( + SetWithAlternateHandler( RequestMethods.ToolsCall, - callToolHandler, + callToolWithAlternateHandler, McpJsonUtilities.JsonContext.Default.CallToolRequestParams, McpJsonUtilities.JsonContext.Default.CallToolResult); } - - private void ConfigureTasks(McpServerOptions options) + private static async ValueTask> InvokeToolWithAlternate( + McpServerTool tool, + RequestContext request, + CancellationToken cancellationToken) { - var taskStore = options.TaskStore; + return await tool.InvokeAsync(request, cancellationToken).ConfigureAwait(false); + } - // If no task store is configured, tasks are not supported - if (taskStore is null) + private McpRequestHandler> BuildComposedCallToolHandler( + McpRequestHandler callToolHandler, + IList>> callToolWithAlternateFilters, + McpServerPrimitiveCollection? tools) + { + return async (request, cancellationToken) => { - return; - } + MatchTool(request, tools); - // Advertise task support in server capabilities - ServerCapabilities.Tasks = new McpTasksCapability - { - List = new ListMcpTasksCapability(), - Cancel = new CancelMcpTasksCapability(), - Requests = new RequestMcpTasksCapability + var invocation = new ComposedCallToolInvocationState(); + var composedHandler = BuildInvocationFilterPipeline( + InvokeOrdinaryPipelineAsync, + callToolWithAlternateFilters); + + try { - Tools = new ToolsMcpTasksCapability + var result = await composedHandler(request, cancellationToken).ConfigureAwait(false); + LogToolCallLifecycles(request, invocation.CompleteOuter(result)); + return result; + } + catch (Exception e) + { + LogToolCallLifecycles( + request, + invocation.CompleteOuterException( + e, + cancellationToken.IsCancellationRequested)); + + if ((e is OperationCanceledException && cancellationToken.IsCancellationRequested) || e is McpProtocolException || e is InputRequiredException) { - Call = new CallToolMcpTasksCapability() + throw; } - } - }; - // tasks/get handler - Retrieve task status - McpRequestHandler getTaskHandler = async (request, cancellationToken) => - { - if (request.Params?.TaskId is not { } taskId) - { - throw new McpProtocolException("Missing required parameter 'taskId'", McpErrorCode.InvalidParams); + return CreateToolCallErrorResult(request, e); } - var task = await taskStore.GetTaskAsync(taskId, SessionId, cancellationToken).ConfigureAwait(false); - if (task is null) + async ValueTask> InvokeOrdinaryPipelineAsync( + RequestContext ordinaryRequest, + CancellationToken ordinaryCancellationToken) { - throw new McpProtocolException($"Task not found: '{taskId}'", McpErrorCode.InvalidParams); - } + try + { + MatchTool(ordinaryRequest, tools); + var result = await callToolHandler(ordinaryRequest, ordinaryCancellationToken).ConfigureAwait(false); + LogToolCallLifecycles(ordinaryRequest, invocation.RecordOrdinaryResult(result)); + return result; + } + catch (Exception exception) + { + LogToolCallLifecycles( + ordinaryRequest, + invocation.RecordOrdinaryException( + exception, + ordinaryCancellationToken.IsCancellationRequested)); + + if ((exception is OperationCanceledException && ordinaryCancellationToken.IsCancellationRequested) || + exception is McpProtocolException || + exception is InputRequiredException) + { + throw; + } - return task; + return CreateToolCallErrorResult(ordinaryRequest, exception); + } + } }; + } - // tasks/result handler - Retrieve task result (blocking until terminal status) - McpRequestHandler getTaskResultHandler = (request, cancellationToken) => + private McpRequestInvocationFilter> BuildInitialAlternateToolFilter( + McpServerPrimitiveCollection? tools) => + async (request, handler, cancellationToken) => { - return new ValueTask(GetTaskResultAsync(request, cancellationToken)); + MatchTool(request, tools); - async Task GetTaskResultAsync(RequestContext request, CancellationToken cancellationToken) + try { - if (request.Params?.TaskId is not { } taskId) + var result = await handler(request, cancellationToken).ConfigureAwait(false); + if (!result.IsAlternate) { - throw new McpProtocolException("Missing required parameter 'taskId'", McpErrorCode.InvalidParams); + ToolCallCompleted(request.Params?.Name ?? string.Empty, result.Result!.IsError is true); } - // Poll until task reaches terminal status - while (true) + return result; + } + catch (Exception e) + { + // Skip logging for InputRequiredException - it's normal MRTR control flow, + // not an error (tools throw it to signal an InputRequiredResult). + if (!(e is OperationCanceledException && cancellationToken.IsCancellationRequested) && e is not InputRequiredException) { - McpTask? task = await taskStore.GetTaskAsync(taskId, SessionId, cancellationToken).ConfigureAwait(false); - if (task is null) - { - throw new McpProtocolException($"Task not found: '{taskId}'", McpErrorCode.InvalidParams); - } - - // If terminal, break and retrieve result - if (task.Status is McpTaskStatus.Completed or McpTaskStatus.Failed or McpTaskStatus.Cancelled) - { - break; - } + ToolCallError(request.Params?.Name ?? string.Empty, e); + } - // Poll according to task's pollInterval (default 1 second) - var pollInterval = task.PollInterval ?? TimeSpan.FromSeconds(1); - await Task.Delay(pollInterval, cancellationToken).ConfigureAwait(false); + if ((e is OperationCanceledException && cancellationToken.IsCancellationRequested) || e is McpProtocolException || e is InputRequiredException) + { + throw; } - // Retrieve the stored result - already stored as JsonElement - return await taskStore.GetTaskResultAsync(taskId, SessionId, cancellationToken).ConfigureAwait(false); + return CreateToolCallErrorResult(request, e); } }; - // tasks/list handler - List tasks with pagination - McpRequestHandler listTasksHandler = async (request, cancellationToken) => + private static void MatchTool( + RequestContext request, + McpServerPrimitiveCollection? tools) + { + if (request.Params?.Name is { } toolName && tools is not null && + tools.TryGetPrimitive(toolName, out var tool)) + { + request.MatchedPrimitive = tool; + } + } + + private static CallToolResult CreateToolCallErrorResult( + RequestContext request, + Exception exception) => + new() { - var cursor = request.Params?.Cursor; - return await taskStore.ListTasksAsync(cursor, SessionId, cancellationToken).ConfigureAwait(false); + IsError = true, + Content = [new TextContentBlock + { + Text = exception is McpException ? + $"An error occurred invoking '{request.Params?.Name}': {exception.Message}" : + $"An error occurred invoking '{request.Params?.Name}'.", + }], }; - // tasks/cancel handler - Cancel a task - McpRequestHandler cancelTaskHandler = async (request, cancellationToken) => + private void LogToolCallLifecycles( + RequestContext request, + IReadOnlyList lifecycles) + { + string toolName = request.Params?.Name ?? string.Empty; + foreach (var lifecycle in lifecycles) { - if (request.Params?.TaskId is not { } taskId) + if (lifecycle.Result is { } result) { - throw new McpProtocolException("Missing required parameter 'taskId'", McpErrorCode.InvalidParams); + ToolCallCompleted(toolName, result.IsError is true); } - - // Signal cancellation if task is still running - _taskCancellationTokenProvider!.Cancel(taskId); - - // Delegate to task store - it handles idempotent cancellation - var task = await taskStore.CancelTaskAsync(taskId, SessionId, cancellationToken).ConfigureAwait(false); - if (task is null) + else if (!(lifecycle.Exception is OperationCanceledException && lifecycle.CancellationRequested) && + lifecycle.Exception is not InputRequiredException) { - throw new McpProtocolException($"Task not found: '{taskId}'", McpErrorCode.InvalidParams); + ToolCallError(toolName, lifecycle.Exception!); } + } + } - return task; - }; +#pragma warning restore MCPEXP002 - // Register handlers - SetHandler( - RequestMethods.TasksGet, - getTaskHandler, - McpJsonUtilities.JsonContext.Default.GetTaskRequestParams, - McpJsonUtilities.JsonContext.Default.McpTask); - - SetHandler( - RequestMethods.TasksResult, - getTaskResultHandler, - McpJsonUtilities.JsonContext.Default.GetTaskPayloadRequestParams, - McpJsonUtilities.JsonContext.Default.JsonElement); - - SetHandler( - RequestMethods.TasksList, - listTasksHandler, - McpJsonUtilities.JsonContext.Default.ListTasksRequestParams, - McpJsonUtilities.JsonContext.Default.ListTasksResult); - - SetHandler( - RequestMethods.TasksCancel, - cancelTaskHandler, - McpJsonUtilities.JsonContext.Default.CancelMcpTaskRequestParams, - McpJsonUtilities.JsonContext.Default.McpTask); - } - - private void ConfigureLogging(McpServerOptions options) - { - // We don't require that the handler be provided, as we always store the provided log level to the server. - var setLoggingLevelHandler = options.Handlers.SetLoggingLevelHandler; + private void ConfigureLogging(McpServerOptions options) + { + // We don't require that the handler be provided, as we always store the provided log level to the server. + var setLoggingLevelHandler = options.Handlers.SetLoggingLevelHandler; // Apply filters to the handler if (setLoggingLevelHandler is not null) @@ -952,6 +1768,13 @@ private void ConfigureLogging(McpServerOptions options) RequestMethods.LoggingSetLevel, (request, jsonRpcRequest, cancellationToken) => { + if (IsJuly2026OrLaterProtocolRequest(jsonRpcRequest)) + { + throw new McpProtocolException( + $"The method '{RequestMethods.LoggingSetLevel}' is not available on protocol version '{jsonRpcRequest.Context?.ProtocolVersion ?? NegotiatedProtocolVersion}'. Use per-request _meta/{MetaKeys.LogLevel} instead.", + McpErrorCode.MethodNotFound); + } + // Store the provided level. if (request is not null) { @@ -969,8 +1792,12 @@ private void ConfigureLogging(McpServerOptions options) return InvokeHandlerAsync(setLoggingLevelHandler, request!, jsonRpcRequest, cancellationToken); } - // Otherwise, consider it handled. - return new ValueTask(EmptyResult.Instance); + // Otherwise, consider it handled. logging/setLevel is a legacy (<= 2025-11-25) method + // (2026-07-28+ is rejected above), so the response must not carry the 2026-07-28 resultType + // field. Return a fresh EmptyResult rather than the shared EmptyResult.Instance, which is + // pre-stamped with resultType="complete" for the 2026-07-28-only subscriptions/listen path + // (issue #1721). + return new ValueTask(new EmptyResult()); }, McpJsonUtilities.JsonContext.Default.SetLevelRequestParams, McpJsonUtilities.JsonContext.Default.EmptyResult); @@ -984,7 +1811,7 @@ private ValueTask InvokeHandlerAsync( { return _servicesScopePerRequest ? InvokeScopedAsync(handler, args, jsonRpcRequest, cancellationToken) : - handler(new(new DestinationBoundMcpServer(this, jsonRpcRequest.Context?.RelatedTransport), jsonRpcRequest, args), cancellationToken); + handler(new(CreateDestinationBoundServer(jsonRpcRequest), jsonRpcRequest, args), cancellationToken); async ValueTask InvokeScopedAsync( McpRequestHandler handler, @@ -996,7 +1823,7 @@ async ValueTask InvokeScopedAsync( try { return await handler( - new RequestContext(new DestinationBoundMcpServer(this, jsonRpcRequest.Context?.RelatedTransport), jsonRpcRequest, args) + new RequestContext(CreateDestinationBoundServer(jsonRpcRequest), jsonRpcRequest, args) { Services = scope?.ServiceProvider ?? Services, }, @@ -1012,18 +1839,107 @@ async ValueTask InvokeScopedAsync( } } + private DestinationBoundMcpServer CreateDestinationBoundServer(JsonRpcRequest jsonRpcRequest) + { + var server = new DestinationBoundMcpServer(this, jsonRpcRequest.Context?.RelatedTransport, jsonRpcRequest.Context); + + if (_mrtrContextsByRequestId.TryRemove(jsonRpcRequest.Id, out var mrtrContext)) + { + server.ActiveMrtrContext = mrtrContext; + } + + return server; + } + private void SetHandler( string method, McpRequestHandler handler, JsonTypeInfo requestTypeInfo, JsonTypeInfo responseTypeInfo) { + // SEP-2549: results that carry caching hints (tools/list, prompts/list, resources/list, + // resources/templates/list, and resources/read) declare ttlMs and cacheScope as required fields. + // When a handler leaves them unset, fill in conservative defaults (immediately stale and not + // shareable) so the wire form always carries the fields while preserving today's "don't cache" + // behavior. Any value supplied by the handler or a filter is left untouched. + if (typeof(ICacheableResult).IsAssignableFrom(typeof(TResult))) + { + var innerHandler = handler; + handler = async (request, cancellationToken) => + { + var result = await innerHandler(request, cancellationToken).ConfigureAwait(false); + + // ttlMs and cacheScope are 2026-07-28 result fields; only stamp them when the request + // was negotiated under that revision or later. Earlier revisions (e.g. 2025-11-25) reject + // these as unrecognized keys (issue #1721). + if (result is ICacheableResult cacheable && IsJuly2026OrLaterProtocolRequest(request.JsonRpcRequest)) + { + cacheable.TimeToLive ??= TimeSpan.Zero; + cacheable.CacheScope ??= CacheScope.Private; + } + + return result; + }; + } + + if (typeof(Result).IsAssignableFrom(typeof(TResult))) + { + var innerHandler = handler; + handler = async (request, cancellationToken) => + { + var result = await innerHandler(request, cancellationToken).ConfigureAwait(false); + + // resultType is a 2026-07-28 result field; only stamp it when the request was negotiated + // under that revision or later. Earlier revisions (e.g. 2025-11-25) reject it as an + // unrecognized key (issue #1721). + if (result is Result protocolResult && protocolResult.ResultType is null && + IsJuly2026OrLaterProtocolRequest(request.JsonRpcRequest)) + { + protocolResult.ResultType = "complete"; + } + + return result; + }; + } + _requestHandlers.Set(method, (request, jsonRpcRequest, cancellationToken) => InvokeHandlerAsync(handler, request, jsonRpcRequest, cancellationToken), requestTypeInfo, responseTypeInfo); } +#pragma warning disable MCPEXP002 // SetWithAlternateHandler wraps the experimental ResultOrAlternate seam + private void SetWithAlternateHandler( + string method, + McpRequestHandler> handler, + JsonTypeInfo requestTypeInfo, + JsonTypeInfo responseTypeInfo) + where TResult : Result + { + var innerHandler = handler; + handler = async (request, cancellationToken) => + { + var result = await innerHandler(request, cancellationToken).ConfigureAwait(false); + + // resultType is a 2026-07-28 result field; only stamp it when the request was negotiated + // under that revision or later. Earlier revisions (e.g. 2025-11-25) reject it as an + // unrecognized key (issue #1721). + if (!result.IsAlternate && result.Result is { ResultType: null } immediateResult && + IsJuly2026OrLaterProtocolRequest(request.JsonRpcRequest)) + { + immediateResult.ResultType = "complete"; + } + + return result; + }; + + _requestHandlers.SetWithAlternate(method, + (request, jsonRpcRequest, cancellationToken) => + InvokeHandlerAsync(handler, request, jsonRpcRequest, cancellationToken), + requestTypeInfo, responseTypeInfo); + } +#pragma warning restore MCPEXP002 + private static McpRequestHandler BuildFilterPipeline( McpRequestHandler baseHandler, IList> filters, @@ -1044,6 +1960,31 @@ private static McpRequestHandler BuildFilterPipeline BuildInvocationFilterPipeline( + McpRequestHandler baseHandler, + IList> filters, + McpRequestInvocationFilter? initialHandler = null) + { + var current = baseHandler; + + for (int i = filters.Count - 1; i >= 0; i--) + { + var next = current; + var filter = filters[i]; + current = (request, cancellationToken) => filter(request, next, cancellationToken); + } + + if (initialHandler is not null) + { + var next = current; + current = (request, cancellationToken) => initialHandler(request, next, cancellationToken); + } + + return current; + } +#pragma warning restore MCPEXP002 + private JsonRpcMessageFilter BuildMessageFilterPipeline(IList filters) { if (filters.Count == 0) @@ -1071,7 +2012,7 @@ private JsonRpcMessageFilter BuildMessageFilterPipeline(IList { // Ensure message has a Context so Items can be shared through the pipeline message.Context ??= new(); - var context = new MessageContext(new DestinationBoundMcpServer(this, message.Context.RelatedTransport), message); + var context = new MessageContext(new DestinationBoundMcpServer(this, message.Context.RelatedTransport, message.Context), message); await current(context, cancellationToken).ConfigureAwait(false); }; }; @@ -1100,177 +2041,492 @@ internal static LoggingLevel ToLoggingLevel(LogLevel level) => _ => Protocol.LoggingLevel.Emergency, }; - [LoggerMessage(Level = LogLevel.Error, Message = "\"{ToolName}\" threw an unhandled exception.")] - private partial void ToolCallError(string toolName, Exception exception); - - [LoggerMessage(Level = LogLevel.Information, Message = "\"{ToolName}\" completed. IsError = {IsError}.")] - private partial void ToolCallCompleted(string toolName, bool isError); - - [LoggerMessage(Level = LogLevel.Error, Message = "GetPrompt \"{PromptName}\" threw an unhandled exception.")] - private partial void GetPromptError(string promptName, Exception exception); + /// + /// Checks whether the negotiated protocol version enables MRTR per SEP-2322 (first available in the + /// 2026-07-28 revision). MRTR rides on the 2026-07-28 revision, so this is the MRTR-meaning alias of + /// - use it at the input-required/handler-suspension + /// sites where the intent is "the client understands " rather than + /// "the peer speaks the 2026-07-28 or later revision". + /// + internal bool ClientSupportsMrtr() => IsJuly2026OrLaterProtocol(); - [LoggerMessage(Level = LogLevel.Information, Message = "GetPrompt \"{PromptName}\" completed.")] - private partial void GetPromptCompleted(string promptName); + /// + /// Returns when the session is stateful - the same server instance handles + /// subsequent requests on the same session. The legacy backcompat resolver in + /// needs a stateful session so it can send + /// elicitation/create / sampling/createMessage / roots/list to the client and + /// retry the handler with the responses. + /// + internal bool HasStatefulTransport() => + _sessionTransport is not StreamableHttpServerTransport { Stateless: true }; + /// + /// Returns when the given request was negotiated under the 2026-07-28 or later protocol + /// revision, derived from the per-request _meta/MCP-Protocol-Version value (so it works + /// for requests over stateless HTTP) and falling back to the session-negotiated version. + /// + private bool IsJuly2026OrLaterProtocolRequest(JsonRpcRequest? request) => + IsJuly2026OrLaterProtocolRequest(request?.Context); - [LoggerMessage(Level = LogLevel.Error, Message = "ReadResource \"{ResourceUri}\" threw an unhandled exception.")] - private partial void ReadResourceError(string resourceUri, Exception exception); + /// + internal bool IsJuly2026OrLaterProtocolRequest(JsonRpcMessageContext? requestContext) => + McpProtocolVersions.IsJuly2026OrLaterProtocolVersion( + requestContext?.ProtocolVersion ?? NegotiatedProtocolVersion); - [LoggerMessage(Level = LogLevel.Information, Message = "ReadResource \"{ResourceUri}\" completed.")] - private partial void ReadResourceCompleted(string resourceUri); + /// + public override bool IsMrtrSupported => ClientSupportsMrtr() || HasStatefulTransport(); /// - /// Executes a tool call as a task and returns a CallToolTaskResult immediately. + /// Invokes a handler and catches to convert it to an + /// JSON response. When MRTR is negotiated or the server is stateless, + /// the result is serialized directly. Otherwise, input requests are resolved via standard JSON-RPC + /// calls (elicitation, sampling, roots) and the handler is retried with the responses - allowing + /// MRTR-native tools to work transparently with clients that don't support MRTR. /// - private async ValueTask ExecuteToolAsTaskAsync( - McpServerTool tool, - RequestContext request, - McpTaskMetadata taskMetadata, - IMcpTaskStore? taskStore, - bool sendNotifications, + private async Task InvokeWithInputRequiredResultHandlingAsync( + Func> handler, + JsonRpcRequest request, CancellationToken cancellationToken) { - if (taskStore is null) + const int MaxRetries = 10; + + for (int retry = 0; ; retry++) { - throw new McpProtocolException( - "Task-augmented requests are not supported. No task store configured.", - McpErrorCode.InvalidRequest); - } + InputRequiredResult inputRequiredResult; + Exception? inputRequiredException = null; - // Create the task in the task store - var mcpTask = await taskStore.CreateTaskAsync( - taskMetadata, - request.JsonRpcRequest.Id, - request.JsonRpcRequest, - SessionId, - cancellationToken).ConfigureAwait(false); - - // Register the task for TTL-based cancellation - var taskCancellationToken = _taskCancellationTokenProvider!.RequestToken(mcpTask.TaskId, mcpTask.TimeToLive); - - // Execute the tool asynchronously in the background - _ = Task.Run(async () => - { - // When per-request service scoping is enabled, InvokeHandlerAsync creates a new - // IServiceScope and disposes it once the handler returns. Since ExecuteToolAsTaskAsync - // returns immediately (before the tool runs), the scope is disposed before the tool - // gets a chance to resolve any DI services. Create a fresh scope here, tied to this - // background task's lifetime, so the tool's DI resolution uses a live provider. - var taskScope = _servicesScopePerRequest - ? Services?.GetService()?.CreateAsyncScope() - : null; - if (taskScope is not null) + try { - request.Services = taskScope.Value.ServiceProvider; - } + var result = await handler(request, cancellationToken).ConfigureAwait(false); - // Set up the task execution context for automatic input_required status tracking - TaskExecutionContext.Current = new TaskExecutionContext + // A handler can surface an input-required result two ways: by throwing InputRequiredException, + // or by RETURNING an InputRequiredResult through the alternate result path (ResultOrAlternate). + // Normalize both forms so a client that doesn't natively support MRTR gets the same server-side + // resolution either way. + if (GetReturnedInputRequiredResult(result) is not { } returnedInputRequired) + { + return result; + } + + inputRequiredResult = returnedInputRequired; + } + catch (InputRequiredException ex) { - TaskId = mcpTask.TaskId, - SessionId = SessionId, - TaskStore = taskStore, - SendNotifications = sendNotifications, - NotifyTaskStatusFunc = NotifyTaskStatusAsync - }; + inputRequiredResult = ex.Result; + inputRequiredException = ex; + } - try + // If the client natively supports MRTR, serialize and return directly - + // the client will drive the retry loop. + if (ClientSupportsMrtr()) { - // Update task status to working - var workingTask = await taskStore.UpdateTaskStatusAsync( - mcpTask.TaskId, - McpTaskStatus.Working, - null, // statusMessage - SessionId, - CancellationToken.None).ConfigureAwait(false); - - // Send notification if enabled - if (sendNotifications) - { - _ = NotifyTaskStatusAsync(workingTask, CancellationToken.None); - } + return SerializeInputRequiredResult(inputRequiredResult); + } - // Invoke the tool with task-specific cancellation token - var result = await tool.InvokeAsync(request, taskCancellationToken).ConfigureAwait(false); - ToolCallCompleted(request.Params?.Name ?? string.Empty, result.IsError is true); + // In stateless mode without MRTR, the server can't resolve input requests via + // JSON-RPC (no persistent session for server-to-client requests), and the client + // won't recognize the InputRequiredResult. This is the one unsupported configuration. + if (!HasStatefulTransport()) + { + throw new McpException( + "A tool handler returned an incomplete result, but the server is stateless and the client does not support MRTR. " + + "MRTR-native tools require either an MRTR-capable client or a stateful server for backward-compatible resolution.", inputRequiredException); + } - // Determine final status based on whether there was an error - var finalStatus = result.IsError is true ? McpTaskStatus.Failed : McpTaskStatus.Completed; + // Backcompat: resolve input requests via standard JSON-RPC calls and retry the handler. + if (inputRequiredResult.InputRequests is not { Count: > 0 } inputRequests) + { + throw new McpException( + "A tool handler returned an incomplete result without input requests, and the client does not support MRTR.", inputRequiredException); + } - // Store the result (serialize to JsonElement) - var resultElement = JsonSerializer.SerializeToElement(result, McpJsonUtilities.JsonContext.Default.CallToolResult); - var finalTask = await taskStore.StoreTaskResultAsync( - mcpTask.TaskId, - finalStatus, - resultElement, - SessionId, - CancellationToken.None).ConfigureAwait(false); + if (retry >= MaxRetries) + { + throw new McpException( + $"MRTR-native tool exceeded {MaxRetries} retry rounds without completing.", inputRequiredException); + } - // Send final notification if enabled - if (sendNotifications) - { - _ = NotifyTaskStatusAsync(finalTask, CancellationToken.None); - } + // Resolve each input request by sending the corresponding JSON-RPC call to the client. + // Route the outgoing requests via the same DestinationBoundMcpServer used for normal tool + // handlers, so they go through the POST's response stream (RelatedTransport) rather than + // the session-level transport. Without this, the messages can race with the client's GET + // stream startup and be silently dropped by StreamableHttpServerTransport.SendMessageAsync + // when no GET request has arrived yet. + var destinationServer = CreateDestinationBoundServer(request); + var inputResponses = await ResolveInputRequestsAsync(destinationServer, inputRequests, cancellationToken).ConfigureAwait(false); + + // Reconstruct request params with inputResponses and requestState for the retry. + var paramsObj = request.Params?.DeepClone() as JsonObject ?? new JsonObject(); + paramsObj["inputResponses"] = JsonSerializer.SerializeToNode( + (IDictionary)inputResponses, McpJsonUtilities.JsonContext.Default.IDictionaryStringInputResponse); + + if (inputRequiredResult.RequestState is { } requestState) + { + paramsObj["requestState"] = requestState; } - catch (OperationCanceledException) when (taskCancellationToken.IsCancellationRequested) + else { - // Task was cancelled via TTL expiration or explicit cancellation. - // For TTL expiration, the task is deleted so no status update needed. - // For explicit cancellation, the cancel handler already updates the status. + // Strip any stale requestState carried over from the previous round's clone so + // the next tool invocation doesn't see a continuation token the current round is not using. + paramsObj.Remove("requestState"); } - catch (Exception ex) + + request = new JsonRpcRequest { - // Log the error - ToolCallError(request.Params?.Name ?? string.Empty, ex); + Id = request.Id, + Method = request.Method, + Params = paramsObj, + Context = request.Context, + }; + } + } - // Store error result - var errorResult = new CallToolResult - { - IsError = true, - Content = [new TextContentBlock { Text = $"Task execution failed: {ex.Message}" }], - }; + /// + /// Resolves a batch of MRTR input requests concurrently by dispatching each as a standard + /// JSON-RPC request to the client. The requests are routed via + /// so they go out through the POST's response stream (matching the behavior of tool-initiated + /// server-to-client requests like server.SampleAsync) and avoid racing with the client's + /// GET stream startup. On the first failure all remaining handlers are cancelled so user-facing + /// flows (sampling/elicitation prompts) don't keep running once the caller has given up, and + /// exceptions from late-completing tasks are observed before the original exception is rethrown. + /// + private static async Task> ResolveInputRequestsAsync( + McpServer destinationServer, + IDictionary inputRequests, + CancellationToken cancellationToken) + { + using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken); - try + var keyed = new (string Key, Task Task)[inputRequests.Count]; + int i = 0; + foreach (var kvp in inputRequests) + { + keyed[i++] = (kvp.Key, ResolveInputRequestAsync(destinationServer, kvp.Value, linkedCts.Token)); + } + + try + { + await Task.WhenAll(Array.ConvertAll(keyed, k => k.Task)).ConfigureAwait(false); + } + catch + { + linkedCts.Cancel(); + try + { + await Task.WhenAll(Array.ConvertAll(keyed, k => k.Task)).ConfigureAwait(false); + } + catch + { + // Observed; the original exception is the one we want to surface. + } + throw; + } + + var responses = new Dictionary(keyed.Length); + foreach (var (key, task) in keyed) + { + responses[key] = task.Result; + } + return responses; + } + + /// + /// Resolves a single MRTR by dispatching it as a standard JSON-RPC + /// request to the client via . This is the server-side mirror + /// of the client's input resolution logic, used for backward compatibility when the client doesn't + /// support MRTR. + /// + private static async Task ResolveInputRequestAsync(McpServer destinationServer, InputRequest inputRequest, CancellationToken cancellationToken) + { + switch (inputRequest.Method) + { + case RequestMethods.ElicitationCreate: + var elicitParams = inputRequest.ElicitationParams + ?? throw new McpException("Failed to deserialize elicitation parameters from MRTR input request."); + var elicitResult = await destinationServer.ElicitAsync(elicitParams, cancellationToken).ConfigureAwait(false); + return InputResponse.FromElicitResult(elicitResult); + + case RequestMethods.SamplingCreateMessage: + var samplingParams = inputRequest.SamplingParams + ?? throw new McpException("Failed to deserialize sampling parameters from MRTR input request."); + var samplingResult = await destinationServer.SampleAsync(samplingParams, cancellationToken).ConfigureAwait(false); + return InputResponse.FromSamplingResult(samplingResult); + + case RequestMethods.RootsList: + var rootsParams = inputRequest.RootsParams ?? new ListRootsRequestParams(); + var rootsResult = await destinationServer.RequestRootsAsync(rootsParams, cancellationToken).ConfigureAwait(false); + return InputResponse.FromRootsResult(rootsResult); + + default: + throw new McpException($"Unsupported input request method: '{inputRequest.Method}'."); + } + } + + private static JsonNode? SerializeInputRequiredResult(InputRequiredResult inputRequiredResult) => + JsonSerializer.SerializeToNode(inputRequiredResult, McpJsonUtilities.JsonContext.Default.InputRequiredResult); + + /// + /// Detects an that a handler surfaced by RETURNING it through the alternate + /// result path (rather than throwing ), so both forms can be resolved + /// identically for clients that don't natively support MRTR. Returns for any other result. + /// + private static InputRequiredResult? GetReturnedInputRequiredResult(JsonNode? result) + { + if (result is JsonObject resultObject && + resultObject.TryGetPropertyValue("resultType", out var resultTypeNode) && + resultTypeNode?.GetValueKind() == JsonValueKind.String && + resultTypeNode.GetValue() == "input_required") + { + return JsonSerializer.Deserialize(result, McpJsonUtilities.JsonContext.Default.InputRequiredResult); + } + + return null; + } + + /// + /// Wraps MRTR-eligible request handlers so that when a handler calls ElicitAsync/SampleAsync/RequestRootsAsync, + /// an is returned early and the handler is suspended until the retry arrives. + /// + private void ConfigureMrtr() + { + // Wrap all methods that may trigger MRTR (server calling ElicitAsync/SampleAsync/RequestRootsAsync + // during handler execution). These methods may produce InputRequiredResult if the handler needs input. + WrapHandlerWithMrtr(RequestMethods.ToolsCall); + WrapHandlerWithMrtr(RequestMethods.PromptsGet); + WrapHandlerWithMrtr(RequestMethods.ResourcesRead); + } + + /// + /// Replaces an existing request handler entry with an MRTR-aware wrapper that supports + /// handler suspension and responses. + /// + private void WrapHandlerWithMrtr(string method) + { + if (!_requestHandlers.TryGetValue(method, out var originalHandler)) + { + return; + } + + _requestHandlers[method] = async (request, cancellationToken) => + { + // Check for MRTR retry: if requestState is present, look up the continuation. + if (request.Params is JsonObject paramsObj && + paramsObj.TryGetPropertyValue("requestState", out var requestStateNode) && + requestStateNode?.GetValueKind() == JsonValueKind.String && + requestStateNode.GetValue() is { } requestState) + { + if (_mrtrContinuations.TryRemove(requestState, out var existingContinuation)) { - var errorResultElement = JsonSerializer.SerializeToElement(errorResult, McpJsonUtilities.JsonContext.Default.CallToolResult); - var failedTask = await taskStore.StoreTaskResultAsync( - mcpTask.TaskId, - McpTaskStatus.Failed, - errorResultElement, - SessionId, - CancellationToken.None).ConfigureAwait(false); - - // Send failure notification if enabled - if (sendNotifications) + // Implicit MRTR retry: resume the suspended handler with client responses. + IDictionary? inputResponses = null; + if (paramsObj.TryGetPropertyValue("inputResponses", out var responsesNode) && responsesNode is not null) { - _ = NotifyTaskStatusAsync(failedTask, CancellationToken.None); + inputResponses = JsonSerializer.Deserialize(responsesNode, McpJsonUtilities.JsonContext.Default.IDictionaryStringInputResponse); } + + var exchange = existingContinuation.PendingExchange!; + var nextExchangeTask = existingContinuation.MrtrContext.ResetForNextExchange(exchange); + + if (inputResponses is not null && + inputResponses.TryGetValue(exchange.Key, out var response)) + { + if (!exchange.ResponseTcs.TrySetResult(response)) + { + throw new McpProtocolException( + $"MRTR exchange '{exchange.Key}' was already completed (possibly cancelled).", + McpErrorCode.InternalError); + } + } + else + { + if (!exchange.ResponseTcs.TrySetException( + new McpProtocolException($"Missing input response for key '{exchange.Key}'.", McpErrorCode.InvalidParams))) + { + throw new McpProtocolException( + $"MRTR exchange '{exchange.Key}' was already completed (possibly cancelled).", + McpErrorCode.InternalError); + } + } + + return await AwaitMrtrHandlerAsync( + existingContinuation.HandlerTask, existingContinuation, nextExchangeTask, cancellationToken).ConfigureAwait(false); } - catch - { - // If we can't store the error result, there's not much we can do - // The task will remain in "working" status, which will eventually be cleaned up - } + + // Explicit MRTR retry or invalid requestState: no continuation found. + // Fall through to the standard MRTR-aware invocation path below. The retry data + // (inputResponses, requestState) is already in the deserialized request params + // for low-level handlers to access, and the MrtrContext will be set up for + // high-level handlers that call ElicitAsync/SampleAsync. + } + + // Implicit MRTR (handler suspension across ElicitAsync/SampleAsync) emits + // InputRequiredResult on the wire, which only 2026-07-28 clients understand, + // and requires the same server instance to handle the retry (stateful session). + // For all other cases - legacy clients, stateless sessions - fall through to the + // exception-based path, which transparently resolves InputRequiredException via + // legacy JSON-RPC requests when the client doesn't speak MRTR. + if (!ClientSupportsMrtr() || !HasStatefulTransport()) + { + return await InvokeWithInputRequiredResultHandlingAsync(originalHandler, request, cancellationToken).ConfigureAwait(false); + } + + // Start a new MRTR-aware handler invocation. + var mrtrContext = new MrtrContext(); + + // Create a long-lived CTS for the handler that survives across retries. + // The original request's combinedCts will be disposed when this lambda returns, + // breaking the cancellation chain. This CTS keeps the handler cancellable. + // Like Kestrel's HttpContext.RequestAborted, the CTS is never disposed - Cancel() + // is thread-safe with itself, and not disposing avoids deadlock risks from + // calling Cancel/Dispose inside locks or Interlocked guards. + var handlerCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken); + + // Store the MrtrContext so CreateDestinationBoundServer can pick it up and set it + // on the per-request DestinationBoundMcpServer. This is picked up synchronously + // before any await, so the finally cleanup is safe. + _mrtrContextsByRequestId[request.Id] = mrtrContext; + Task handlerTask; + try + { + handlerTask = originalHandler(request, handlerCts.Token); } finally { - // Clean up task execution context - TaskExecutionContext.Current = null; + _mrtrContextsByRequestId.TryRemove(request.Id, out _); + } - // Clean up task cancellation tracking - _taskCancellationTokenProvider!.Complete(mcpTask.TaskId); + // Wrap handler state into a continuation for lifecycle management across retries. + var continuation = new MrtrContinuation(handlerCts, handlerTask, mrtrContext); - // Dispose the per-task service scope (if one was created) - if (taskScope is not null) - { - await taskScope.Value.DisposeAsync().ConfigureAwait(false); - } - } - }, CancellationToken.None); + // Track the handler task for lifecycle management. The observer logs unhandled + // exceptions and decrements _mrtrInFlightCount when the handler completes, + // mirroring how McpSessionHandler tracks in-flight handlers. + Interlocked.Increment(ref _mrtrInFlightCount); + _ = ObserveHandlerCompletionAsync(handlerTask); + + return await AwaitMrtrHandlerAsync( + handlerTask, continuation, mrtrContext.InitialExchangeTask, cancellationToken).ConfigureAwait(false); + }; + } + + /// + /// Awaits the outcome of an MRTR-enabled handler invocation. + /// If the handler completes, returns its result. If an exchange arrives (handler needs input), + /// builds and returns an and stores the continuation for future retries. + /// If the handler throws , the result is returned directly + /// without storing a continuation (explicit MRTR path). + /// + private async Task AwaitMrtrHandlerAsync( + Task handlerTask, + MrtrContinuation continuation, + Task exchangeTask, + CancellationToken cancellationToken) + { + // Link the current request's cancellation to the handler's long-lived CTS. + // On the initial call this is redundant (handlerCts is already linked to cancellationToken) + // but on retries this is critical: the retry's combinedCts cancellation must flow to the handler. + // This is how notifications/cancelled for the retry's request ID reaches the handler. + using var registration = cancellationToken.Register( + static state => ((MrtrContinuation)state!).CancelHandler(), continuation); - // Return the task result immediately - return new CallToolResult + // Race handler against MRTR exchange. + var completedTask = await Task.WhenAny(handlerTask, exchangeTask).ConfigureAwait(false); + + if (completedTask == handlerTask) { - Task = mcpTask + // Handler completed - return its result, propagate its exception, or handle InputRequiredException. + return await AwaitHandlerWithInputRequiredResultHandlingAsync(handlerTask).ConfigureAwait(false); + } + + // Exchange arrived - handler needs input from the client (implicit MRTR path). + var exchange = await exchangeTask.ConfigureAwait(false); + + var correlationId = Guid.NewGuid().ToString("N"); + var inputRequiredResult = new InputRequiredResult + { + InputRequests = new Dictionary { [exchange.Key] = exchange.InputRequest }, + RequestState = correlationId, }; + + // Store the continuation so the retry can resume the handler. + continuation.PendingExchange = exchange; + _mrtrContinuations[correlationId] = continuation; + + return SerializeInputRequiredResult(inputRequiredResult); } + + /// + /// Fire-and-forget observer for an MRTR handler task. Logs unhandled exceptions at Debug + /// level (the same exception still propagates to the request pipeline, so Debug avoids + /// double-reporting at Error) and decrements when the + /// handler completes, following the same in-flight tracking pattern as . + /// + private async Task ObserveHandlerCompletionAsync(Task handlerTask) + { + try + { + await handlerTask.ConfigureAwait(false); + } + catch (OperationCanceledException) + { + // Handler cancelled - expected lifecycle event (disposal, client cancel, session shutdown). + } + catch (InputRequiredException) + { + // Explicit MRTR: handler explicitly signaling an InputRequiredResult. Not an error. + } + catch (Exception ex) + { + MrtrHandlerError(ex); + } + finally + { + if (Interlocked.Decrement(ref _mrtrInFlightCount) == 0) + { + _allMrtrHandlersCompleted.TrySetResult(true); + } + } + } + + /// + /// Awaits a handler task, catching to convert it to an + /// JSON response without storing a continuation. + /// + private static async Task AwaitHandlerWithInputRequiredResultHandlingAsync(Task handlerTask) + { + try + { + return await handlerTask.ConfigureAwait(false); + } + catch (InputRequiredException ex) + { + return SerializeInputRequiredResult(ex.Result); + } + } + + [LoggerMessage(Level = LogLevel.Error, Message = "\"{ToolName}\" threw an unhandled exception.")] + private partial void ToolCallError(string toolName, Exception exception); + + [LoggerMessage(Level = LogLevel.Information, Message = "\"{ToolName}\" completed. IsError = {IsError}.")] + private partial void ToolCallCompleted(string toolName, bool isError); + + [LoggerMessage(Level = LogLevel.Error, Message = "GetPrompt \"{PromptName}\" threw an unhandled exception.")] + private partial void GetPromptError(string promptName, Exception exception); + + [LoggerMessage(Level = LogLevel.Information, Message = "GetPrompt \"{PromptName}\" completed.")] + private partial void GetPromptCompleted(string promptName); + + [LoggerMessage(Level = LogLevel.Error, Message = "ReadResource \"{ResourceUri}\" threw an unhandled exception.")] + private partial void ReadResourceError(string resourceUri, Exception exception); + + [LoggerMessage(Level = LogLevel.Information, Message = "ReadResource \"{ResourceUri}\" completed.")] + private partial void ReadResourceCompleted(string resourceUri); + + [LoggerMessage(Level = LogLevel.Debug, Message = "Cancelled {Count} pending MRTR continuation(s) during session disposal.")] + private partial void MrtrContinuationsCancelled(int count); + + [LoggerMessage(Level = LogLevel.Debug, Message = "An MRTR handler threw an unhandled exception.")] + private partial void MrtrHandlerError(Exception exception); + + [LoggerMessage(Level = LogLevel.Debug, Message = "Failed to deliver \"{NotificationMethod}\" to subscription \"{SubscriptionId}\".")] + private partial void SubscriptionNotificationFailed(string notificationMethod, string subscriptionId, Exception exception); } diff --git a/src/ModelContextProtocol.Core/Server/McpServerOptions.cs b/src/ModelContextProtocol.Core/Server/McpServerOptions.cs index 6da8bbfbe..2a26868a1 100644 --- a/src/ModelContextProtocol.Core/Server/McpServerOptions.cs +++ b/src/ModelContextProtocol.Core/Server/McpServerOptions.cs @@ -1,6 +1,8 @@ using ModelContextProtocol.Protocol; using System.Diagnostics.CodeAnalysis; +#pragma warning disable MCPEXP001, MCPEXP002 + namespace ModelContextProtocol.Server; /// @@ -12,7 +14,8 @@ public sealed class McpServerOptions /// Gets or sets information about this server implementation, including its name and version. /// /// - /// This information is sent to the client during initialization to identify the server. + /// This information is sent in the initialization result on handshake-based protocol revisions and in + /// every successful result's metadata on per-request-metadata revisions. /// It's displayed in client logs and can be used for debugging and compatibility checks. /// public Implementation? ServerInfo { get; set; } @@ -31,11 +34,23 @@ public sealed class McpServerOptions /// Gets or sets the protocol version supported by this server, using a date-based versioning scheme. /// /// - /// The protocol version defines which features and message formats this server supports. - /// This uses a date-based versioning scheme in the format "YYYY-MM-DD". - /// If , the server will advertise to the client the version requested - /// by the client if that version is known to be supported, and otherwise will advertise the latest - /// version supported by the server. + /// + /// The protocol version defines which features and message formats this server supports. Supported + /// values are 2024-11-05, 2025-03-26, 2025-06-18, 2025-11-25, and + /// 2026-07-28. + /// + /// + /// If , the server supports all of the versions listed above. For clients using + /// the initialize handshake, the server returns the requested initialize-capable version when it + /// is supported and otherwise returns 2025-11-25. For clients using server/discover and + /// per-request metadata, the server advertises the supported per-request metadata versions; currently + /// this is 2026-07-28. + /// + /// + /// Set this property to a specific supported value to pin the server to that version. Setting it to + /// 2026-07-28 makes the server reject initialize handshakes; setting it to an earlier + /// value makes the server reject 2026-07-28 per-request metadata. + /// /// public string? ProtocolVersion { get; set; } @@ -72,12 +87,13 @@ public sealed class McpServerOptions public bool ScopeRequests { get; set; } = true; /// - /// Gets or sets preexisting knowledge about the client including its name and version to help support - /// stateless Streamable HTTP servers that encode this knowledge in the mcp-session-id header. + /// Gets or sets preexisting knowledge about the client including its name and version. /// /// /// - /// When not specified, this information is sourced from the client's initialize request. + /// When not specified, this information is sourced from the client's initialize request or, + /// for protocol versions that use per-request metadata, from the current request's _meta field. + /// This is typically set during session migration in conjunction with . /// /// public Implementation? KnownClientInfo { get; set; } @@ -88,7 +104,8 @@ public sealed class McpServerOptions /// /// /// - /// When not specified, this information is sourced from the client's initialize request. + /// When not specified, this information is sourced from the client's initialize request or, + /// for protocol versions that use per-request metadata, from the current request's _meta field. /// This is typically set during session migration in conjunction with . /// /// @@ -185,57 +202,22 @@ public McpServerFilters Filters /// This value is used in /// when is not set in the request options. /// + [Obsolete(Obsoletions.DeprecatedSampling_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public int MaxSamplingOutputTokens { get; set; } = 1000; /// - /// Gets or sets the task store for managing asynchronous task execution. - /// - /// - /// - /// When non-null, enables explicit task support with persistence, allowing clients to: - /// - /// Execute operations asynchronously by augmenting requests with task metadata - /// Poll for task status via tasks/get requests - /// Retrieve task results via tasks/result requests - /// List all tasks via tasks/list requests - /// Cancel tasks via tasks/cancel requests - /// - /// - /// - /// When null, implicit task support may still be available for async methods (returning or - /// ), but tasks will be ephemeral and not persisted. Use - /// for development/testing or implement for production scenarios. - /// - /// - /// The server will automatically advertise task capabilities based on the presence of a task store - /// and the detection of async server primitives (tools, prompts, resources). - /// - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - public IMcpTaskStore? TaskStore { get; set; } - - /// - /// Gets or sets whether to send task status notifications to clients. + /// Gets or sets custom request handlers to register with the server. /// - /// - /// to send optional notifications/tasks/status notifications when task status changes; - /// to not send notifications. The default is . - /// /// /// - /// When enabled, the server will send notifications/tasks/status notifications to inform clients - /// of task state changes. According to the MCP specification, these notifications are optional and - /// receivers MAY send them but are not required to. - /// - /// - /// Clients must not rely on receiving these notifications and should continue polling via tasks/get - /// requests to ensure they receive status updates. + /// Each registers a raw JSON-RPC method handler that + /// bypasses the typed handler infrastructure. This enables extensions to register handlers + /// for methods not known to Core at compile time. /// /// - /// Even when this is set to , notifications are only sent when - /// is configured, as task-augmented requests require a task store. + /// Handlers registered here take precedence over built-in handlers for the same method. /// /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - public bool SendTaskStatusNotifications { get; set; } + [Experimental(Experimentals.Extensibility_DiagnosticId, UrlFormat = Experimentals.Extensibility_Url)] + public IList? RequestHandlers { get; set; } } diff --git a/src/ModelContextProtocol.Core/Server/McpServerPrimitiveCollection.cs b/src/ModelContextProtocol.Core/Server/McpServerPrimitiveCollection.cs index e126fb13d..aa281989b 100644 --- a/src/ModelContextProtocol.Core/Server/McpServerPrimitiveCollection.cs +++ b/src/ModelContextProtocol.Core/Server/McpServerPrimitiveCollection.cs @@ -12,6 +12,15 @@ public class McpServerPrimitiveCollection : ICollection, IReadOnlyCollecti /// Concurrent dictionary of primitives, indexed by their names. private readonly ConcurrentDictionary _primitives; + /// Lock protecting and . + private readonly object _deferralLock = new(); + + /// Depth counter for active scopes. Positive means notifications are deferred. + private int _activeDeferralScopes; + + /// Whether a change occurred while notifications were deferred. + private bool _hasDeferredChangeEvents; + /// /// Initializes a new instance of the class. /// @@ -33,8 +42,85 @@ public McpServerPrimitiveCollection(IEqualityComparer? keyComparer = nul /// Gets a value that indicates whether there are any primitives in the collection. public bool IsEmpty => _primitives.IsEmpty; + /// + /// Begins a deferred-change scope. notifications are suppressed + /// until the returned scope is disposed, at which point a single notification is raised + /// if any mutation occurred during the scope. Multiple scopes may be active simultaneously; + /// the notification fires once all active scopes have been disposed. + /// + /// An that ends the deferral scope when disposed. + /// + /// The scope is exception-safe: even if an exception is thrown inside a using block, + /// the deferral is ended on dispose. If any mutation occurred before the exception, a single + /// notification is raised. + /// + /// Mutations from any thread during an open scope are coalesced. A single + /// notification fires on the thread that disposes the last active scope, only if at least one + /// mutation occurred. All deferral state transitions are guarded by an internal lock, so + /// concurrent mutations and concurrent scope disposal are both safe. Disposing the same scope + /// instance more than once is safe and has no additional effect. + /// + /// + public IDisposable DeferChangedEvents() + { + lock (_deferralLock) + { + _activeDeferralScopes++; + } + return new ChangeDeferralScope(this); + } + /// Raises if there are registered handlers. - protected void RaiseChanged() => Changed?.Invoke(this, EventArgs.Empty); + /// + /// If a scope is active, the notification is deferred until all + /// active scopes are disposed. Derived types that override mutation methods and call + /// will automatically participate in deferral. + /// + protected void RaiseChanged() + { + lock (_deferralLock) + { + if (_activeDeferralScopes > 0) + { + _hasDeferredChangeEvents = true; + return; + } + } + + Changed?.Invoke(this, EventArgs.Empty); + } + + private void EndDeferral() + { + bool raise; + lock (_deferralLock) + { + raise = --_activeDeferralScopes == 0 && _hasDeferredChangeEvents; + if (raise) + { + _hasDeferredChangeEvents = false; + } + } + + if (raise) + { + Changed?.Invoke(this, EventArgs.Empty); + } + } + + private sealed class ChangeDeferralScope : IDisposable + { + private McpServerPrimitiveCollection? _collection; + + public ChangeDeferralScope(McpServerPrimitiveCollection collection) => + _collection = collection; + + public void Dispose() + { + McpServerPrimitiveCollection? collection = Interlocked.Exchange(ref _collection, null); + collection?.EndDeferral(); + } + } /// Gets the with the specified from the collection. /// The name of the primitive to retrieve. diff --git a/src/ModelContextProtocol.Core/Server/McpServerRequestHandler.cs b/src/ModelContextProtocol.Core/Server/McpServerRequestHandler.cs new file mode 100644 index 000000000..af8a94091 --- /dev/null +++ b/src/ModelContextProtocol.Core/Server/McpServerRequestHandler.cs @@ -0,0 +1,46 @@ +using ModelContextProtocol.Protocol; +using System.Diagnostics.CodeAnalysis; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.Server; + +/// +/// Represents a custom request handler that can be registered with the MCP server to handle +/// arbitrary JSON-RPC methods. +/// +/// +/// +/// Custom request handlers are registered via and +/// are invoked when a JSON-RPC request with the matching is received. +/// The handler receives the raw and returns a serialized +/// response, giving extensions full control over request/response serialization. +/// +/// +[Experimental(Experimentals.Extensibility_DiagnosticId, UrlFormat = Experimentals.Extensibility_Url)] +public sealed class McpServerRequestHandler +{ + /// + /// Gets the JSON-RPC method name this handler responds to. + /// + public required string Method { get; init; } + + /// + /// Gets the name of the top-level request parameter whose value is mirrored in the + /// Mcp-Name HTTP routing header. + /// + /// + /// When set, Streamable HTTP servers require the request to include an Mcp-Name + /// header whose decoded value matches the string value of this parameter. + /// + [Experimental(Experimentals.Extensibility_DiagnosticId, UrlFormat = Experimentals.Extensibility_Url)] + public string? RoutingNameParameter { get; init; } + + /// + /// Gets the handler function that processes incoming requests for the specified method. + /// + /// + /// The handler receives the full and a , + /// and returns a serialized response (or for void methods). + /// + public required Func> Handler { get; init; } +} diff --git a/src/ModelContextProtocol.Core/Server/McpServerToolAttribute.cs b/src/ModelContextProtocol.Core/Server/McpServerToolAttribute.cs index d67bac18c..34e77e2b4 100644 --- a/src/ModelContextProtocol.Core/Server/McpServerToolAttribute.cs +++ b/src/ModelContextProtocol.Core/Server/McpServerToolAttribute.cs @@ -157,7 +157,6 @@ public sealed class McpServerToolAttribute : Attribute internal bool? _idempotent; internal bool? _openWorld; internal bool? _readOnly; - internal ToolTaskSupport? _taskSupport; /// /// Initializes a new instance of the class. @@ -300,29 +299,4 @@ public bool ReadOnly /// /// public string? IconSource { get; set; } - - /// - /// Gets or sets the task support configuration for the tool. - /// - /// - /// A value indicating how the tool supports task-based invocation. - /// The default value is . - /// - /// - /// - /// When set to , clients must not attempt to invoke the tool as a task. - /// When set to , clients may invoke the tool as a task or as a normal request. - /// When set to , clients must invoke the tool as a task. - /// - /// - /// If this property is not explicitly set on the attribute, the task support behavior will be determined - /// automatically based on the tool's characteristics (e.g., async methods default to ). - /// - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - public ToolTaskSupport TaskSupport - { - get => _taskSupport ?? ToolTaskSupport.Forbidden; - set => _taskSupport = value; - } } diff --git a/src/ModelContextProtocol.Core/Server/McpServerToolCreateOptions.cs b/src/ModelContextProtocol.Core/Server/McpServerToolCreateOptions.cs index 88d718d13..b0b6b3de7 100644 --- a/src/ModelContextProtocol.Core/Server/McpServerToolCreateOptions.cs +++ b/src/ModelContextProtocol.Core/Server/McpServerToolCreateOptions.cs @@ -197,23 +197,6 @@ public sealed class McpServerToolCreateOptions /// public JsonObject? Meta { get; set; } - /// - /// Gets or sets the execution hints for this tool. - /// - /// - /// - /// Execution hints provide information about how the tool should be invoked, including - /// task support level (). - /// - /// - /// If , the tool's execution settings are determined automatically based on - /// the method signature (async methods get ; sync methods - /// get ). - /// - /// - [Experimental(Experimentals.Tasks_DiagnosticId, UrlFormat = Experimentals.Tasks_Url)] - public ToolExecution? Execution { get; set; } - /// /// Creates a shallow clone of the current instance. /// @@ -235,6 +218,5 @@ internal McpServerToolCreateOptions Clone() => Metadata = Metadata, Icons = Icons, Meta = Meta, - Execution = Execution, }; } diff --git a/src/ModelContextProtocol.Core/Server/MrtrContext.cs b/src/ModelContextProtocol.Core/Server/MrtrContext.cs new file mode 100644 index 000000000..e849cf4eb --- /dev/null +++ b/src/ModelContextProtocol.Core/Server/MrtrContext.cs @@ -0,0 +1,78 @@ +using ModelContextProtocol.Protocol; + +namespace ModelContextProtocol.Server; + +/// +/// Manages the MRTR (Multi Round-Trip Request) coordination between a handler and the pipeline. +/// When a handler calls or +/// , +/// the handler sets the exchange TCS and suspends on a response TCS. The pipeline detects the exchange +/// via or the task returned by , +/// sends an , and later completes the response TCS when the retry arrives. +/// +internal sealed class MrtrContext +{ + private TaskCompletionSource _exchangeTcs = new(TaskCreationOptions.RunContinuationsAsynchronously); + private int _nextInputRequestId; + + /// + /// Gets the task for the initial MRTR exchange. Set once in the constructor and never changes. + /// For subsequent exchanges after a retry, use the task returned by . + /// + public Task InitialExchangeTask { get; } + + public MrtrContext() + { + InitialExchangeTask = _exchangeTcs.Task; + } + + /// + /// Prepares the context for the next round of exchange after a retry arrives. + /// Uses to atomically validate that + /// still references the TCS that produced , + /// ensuring concurrent calls reliably fail. + /// + /// The exchange from the previous round whose + /// response has been (or is about to be) completed. + /// A task that completes when the handler requests input via + /// . + /// The context state was modified concurrently. + public Task ResetForNextExchange(MrtrExchange previousExchange) + { + var newTcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + if (Interlocked.CompareExchange(ref _exchangeTcs, newTcs, previousExchange.SourceTcs) != previousExchange.SourceTcs) + { + throw new InvalidOperationException("MrtrContext was modified concurrently."); + } + + return newTcs.Task; + } + + /// + /// Called by + /// or + /// to request input from the client via the MRTR mechanism. + /// + /// The input request describing what the server needs. + /// A token to cancel the wait for input. + /// The client's response to the input request. + /// A concurrent server-to-client request is already pending. + public async Task RequestInputAsync(InputRequest inputRequest, CancellationToken cancellationToken) + { + var key = $"input_{Interlocked.Increment(ref _nextInputRequestId)}"; + var tcs = _exchangeTcs; + var exchange = new MrtrExchange(key, inputRequest, tcs); + + // TrySetResult is the sole atomicity gate. If it returns false, + // the TCS was already completed by a prior call - concurrent exchanges + // are not supported. + if (!tcs.TrySetResult(exchange)) + { + throw new InvalidOperationException( + "Concurrent server-to-client requests are not supported. " + + "Await each ElicitAsync, SampleAsync, or RequestRootsAsync call before making another."); + } + + return await exchange.ResponseTcs.Task.WaitAsync(cancellationToken).ConfigureAwait(false); + } +} diff --git a/src/ModelContextProtocol.Core/Server/MrtrContinuation.cs b/src/ModelContextProtocol.Core/Server/MrtrContinuation.cs new file mode 100644 index 000000000..f2cc65e3f --- /dev/null +++ b/src/ModelContextProtocol.Core/Server/MrtrContinuation.cs @@ -0,0 +1,50 @@ +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.Server; + +/// +/// Represents the lifecycle state for an MRTR handler invocation across retries. +/// Created when the handler starts and stored in _mrtrContinuations when +/// the handler suspends waiting for client input. +/// +internal sealed class MrtrContinuation +{ + private readonly CancellationTokenSource _handlerCts; + + public MrtrContinuation(CancellationTokenSource handlerCts, Task handlerTask, MrtrContext mrtrContext) + { + _handlerCts = handlerCts; + HandlerTask = handlerTask; + MrtrContext = mrtrContext; + } + + /// + /// Gets a token that cancels when the handler should be aborted. + /// Passed to the handler at creation and remains valid across retries. + /// + public CancellationToken HandlerToken => _handlerCts.Token; + + /// + /// The handler task that is suspended awaiting input. + /// + public Task HandlerTask { get; } + + /// + /// The MRTR context for the handler's async flow. + /// + public MrtrContext MrtrContext { get; } + + /// + /// The exchange that is awaiting a response from the client. + /// Set each time the handler suspends on a new exchange. + /// + public MrtrExchange? PendingExchange { get; set; } + + /// + /// Cancels the handler. Safe to call multiple times and concurrently - + /// is thread-safe with itself. + /// The CTS is intentionally never disposed to avoid deadlock risks from + /// calling Cancel/Dispose inside synchronization primitives. + /// + public void CancelHandler() => _handlerCts.Cancel(); +} diff --git a/src/ModelContextProtocol.Core/Server/MrtrExchange.cs b/src/ModelContextProtocol.Core/Server/MrtrExchange.cs new file mode 100644 index 000000000..cf0a86af4 --- /dev/null +++ b/src/ModelContextProtocol.Core/Server/MrtrExchange.cs @@ -0,0 +1,41 @@ +using ModelContextProtocol.Protocol; + +namespace ModelContextProtocol.Server; + +/// +/// Represents a single exchange between the handler and the pipeline during an MRTR flow. +/// The handler creates the exchange and awaits the response TCS. The pipeline reads the exchange, +/// sends the to the client, and completes the TCS when the response arrives. +/// +internal sealed class MrtrExchange +{ + public MrtrExchange(string key, InputRequest inputRequest, TaskCompletionSource sourceTcs) + { + Key = key; + InputRequest = inputRequest; + SourceTcs = sourceTcs; + ResponseTcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + } + + /// + /// The unique key identifying this exchange within the MRTR round trip. + /// + public string Key { get; } + + /// + /// The input request that needs to be fulfilled by the client. + /// + public InputRequest InputRequest { get; } + + /// + /// The that this exchange was set as the result of. + /// Used by on retry to validate + /// the expected state via . + /// + internal TaskCompletionSource SourceTcs { get; } + + /// + /// The TCS that will be completed with the client's response. + /// + public TaskCompletionSource ResponseTcs { get; } +} diff --git a/src/ModelContextProtocol.Core/Server/OutgoingRequestInterceptingMcpServer.cs b/src/ModelContextProtocol.Core/Server/OutgoingRequestInterceptingMcpServer.cs new file mode 100644 index 000000000..93b7e5e73 --- /dev/null +++ b/src/ModelContextProtocol.Core/Server/OutgoingRequestInterceptingMcpServer.cs @@ -0,0 +1,56 @@ +using ModelContextProtocol.Protocol; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.Server; + +#pragma warning disable MCPEXP002 +internal sealed class OutgoingRequestInterceptingMcpServer( + McpServer server, + Func> interceptor) : McpServer +#pragma warning restore MCPEXP002 +{ + internal override Func>? OutgoingRequestInterceptor => interceptor; + + public override string? SessionId => server.SessionId; + + public override string? NegotiatedProtocolVersion => server.NegotiatedProtocolVersion; + + public override ClientCapabilities? ClientCapabilities => server.ClientCapabilities; + + public override Implementation? ClientInfo => server.ClientInfo; + + public override McpServerOptions ServerOptions => server.ServerOptions; + + public override IServiceProvider? Services => server.Services; + + [Obsolete(Obsoletions.DeprecatedLogging_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] + public override LoggingLevel? LoggingLevel => server.LoggingLevel; + + public override bool IsMrtrSupported => server.IsMrtrSupported; + + public override ValueTask DisposeAsync() => server.DisposeAsync(); + + public override IAsyncDisposable RegisterNotificationHandler( + string method, + Func handler) => + server.RegisterNotificationHandler(method, handler); + + public override Task RunAsync(CancellationToken cancellationToken = default) => + server.RunAsync(cancellationToken); + + public override Task SendMessageAsync(JsonRpcMessage message, CancellationToken cancellationToken = default) => + server.SendMessageAsync(message, cancellationToken); + + public override async Task SendRequestAsync( + JsonRpcRequest request, + CancellationToken cancellationToken = default) + { + Throw.IfNull(request); + + return new JsonRpcResponse + { + Id = request.Id, + Result = await interceptor(request.Method, request.Params, cancellationToken).ConfigureAwait(false), + }; + } +} diff --git a/src/ModelContextProtocol.Core/Server/SseEventStreamMode.cs b/src/ModelContextProtocol.Core/Server/SseEventStreamMode.cs index 2b7704d3d..3439acc60 100644 --- a/src/ModelContextProtocol.Core/Server/SseEventStreamMode.cs +++ b/src/ModelContextProtocol.Core/Server/SseEventStreamMode.cs @@ -3,6 +3,7 @@ namespace ModelContextProtocol.Server; /// /// Represents the mode of an SSE event stream. /// +[Obsolete(Obsoletions.LegacyStatefulHttp_Message, DiagnosticId = Obsoletions.LegacyStatefulHttp_DiagnosticId, UrlFormat = Obsoletions.LegacyStatefulHttp_Url)] public enum SseEventStreamMode { /// diff --git a/src/ModelContextProtocol.Core/Server/SseEventStreamOptions.cs b/src/ModelContextProtocol.Core/Server/SseEventStreamOptions.cs index 6d5be24ef..7eea0973c 100644 --- a/src/ModelContextProtocol.Core/Server/SseEventStreamOptions.cs +++ b/src/ModelContextProtocol.Core/Server/SseEventStreamOptions.cs @@ -3,6 +3,7 @@ namespace ModelContextProtocol.Server; /// /// Configuration options for creating an SSE event stream. /// +[Obsolete(Obsoletions.LegacyStatefulHttp_Message, DiagnosticId = Obsoletions.LegacyStatefulHttp_DiagnosticId, UrlFormat = Obsoletions.LegacyStatefulHttp_Url)] public sealed class SseEventStreamOptions { /// diff --git a/src/ModelContextProtocol.Core/Server/StreamServerTransport.cs b/src/ModelContextProtocol.Core/Server/StreamServerTransport.cs index 5e1a106c5..c8c5d8408 100644 --- a/src/ModelContextProtocol.Core/Server/StreamServerTransport.cs +++ b/src/ModelContextProtocol.Core/Server/StreamServerTransport.cs @@ -137,7 +137,33 @@ private async Task ReadMessagesAsync() LogTransportMessageParseFailed(Name, ex); } - // Continue reading even if we fail to parse a message + // Deserializing the full message failed, for example because the params object was nested + // more deeply than the JSON reader's MaxDepth allows. If the message still carried a request + // id, reply with a JSON-RPC parse error using that id so the caller's pending request + // completes instead of hanging until it times out. If no id can be recovered, the message + // was either a notification or too malformed to correlate, so we just continue reading. + if (TryRecoverRequestId(line, out RequestId id)) + { + var errorResponse = new JsonRpcError + { + Id = id, + Error = new JsonRpcErrorDetail + { + Code = (int)McpErrorCode.ParseError, + Message = "Failed to parse the JSON-RPC request.", + }, + }; + + try + { + await SendMessageAsync(errorResponse, shutdownToken).ConfigureAwait(false); + } + catch (Exception sendEx) when (sendEx is not OperationCanceledException) + { + // Swallow so a failed error-send does not tear down the read loop. No logging + // here because SendMessageAsync already logs send failures before it throws. + } + } } } } @@ -156,6 +182,85 @@ private async Task ReadMessagesAsync() } } + /// + /// Attempts to recover the JSON-RPC request id from a line that failed full deserialization. + /// + /// + /// This walks only the top-level object looking for an "id" property and skips every other value, + /// using a large reader depth so a deeply nested "params" value cannot make recovery itself fail. + /// + private static bool TryRecoverRequestId(string line, out RequestId id) + { + id = default; + + try + { + byte[] utf8 = Encoding.UTF8.GetBytes(line); + var reader = new Utf8JsonReader(utf8, new JsonReaderOptions + { + // Use the maximum reader depth so that an over-nested "params" value cannot make id + // recovery throw for the same reason the original parse did. + MaxDepth = int.MaxValue, + }); + + if (!reader.Read() || reader.TokenType != JsonTokenType.StartObject) + { + return false; + } + + while (reader.Read()) + { + if (reader.TokenType == JsonTokenType.EndObject) + { + break; + } + + if (reader.TokenType != JsonTokenType.PropertyName) + { + continue; + } + + bool isId = reader.ValueTextEquals("id"u8); + + if (!reader.Read()) + { + break; + } + + if (isId) + { + switch (reader.TokenType) + { + case JsonTokenType.String: + id = new RequestId(reader.GetString()!); + return true; + + case JsonTokenType.Number when reader.TryGetInt64(out long longId): + id = new RequestId(longId); + return true; + + default: + // An id that is neither a string nor an integer cannot be correlated, so + // there is no point sending an error response for it. + return false; + } + } + + // Skip the value of any property other than id, including a deeply nested params object. + reader.Skip(); + } + } + catch (Exception) + { + // Recovery is best effort. Whether the line was too malformed to locate a top-level id or + // the reader failed for any other reason, swallow it here and return false. Letting an + // exception escape would propagate out of the read loop and disconnect the transport, + // turning a single bad message into a full session teardown. + } + + return false; + } + /// public override async ValueTask DisposeAsync() { diff --git a/src/ModelContextProtocol.Core/Server/StreamableHttpPostTransport.cs b/src/ModelContextProtocol.Core/Server/StreamableHttpPostTransport.cs index 568afd223..95411f7e2 100644 --- a/src/ModelContextProtocol.Core/Server/StreamableHttpPostTransport.cs +++ b/src/ModelContextProtocol.Core/Server/StreamableHttpPostTransport.cs @@ -15,18 +15,22 @@ internal sealed partial class StreamableHttpPostTransport( StreamableHttpServerTransport parentTransport, Stream responseStream, CancellationToken sessionCancellationToken, - ILogger logger) : ITransport + ILogger logger, + Func? onResponseStarting = null) : ITransport { private readonly SemaphoreSlim _messageLock = new(1, 1); private readonly TaskCompletionSource _httpResponseTcs = new(TaskCreationOptions.RunContinuationsAsynchronously); private readonly SseEventWriter _httpSseWriter = new(responseStream); private TaskCompletionSource? _storeStreamTcs; +#pragma warning disable MCP9006 // Stateful Streamable HTTP resumability types are obsolete but still wired up internally. private ISseEventStreamWriter? _storeSseWriter; +#pragma warning restore MCP9006 private RequestId _pendingRequest; private bool _finalResponseMessageSent; private bool _httpResponseCompleted; + private bool _httpResponseStarted; public ChannelReader MessageReader => throw new NotSupportedException("JsonRpcMessage.Context.RelatedTransport should only be used for sending messages."); @@ -48,8 +52,13 @@ public async ValueTask HandlePostAsync(JsonRpcMessage message, Cancellatio _pendingRequest = request.Id; message.Context.RelatedTransport = this; - // Invoke the initialize request handler if applicable. - if (request.Method == RequestMethods.Initialize) + // Invoke the initialize request handler if applicable. On a per-request-metadata + // protocol revision (2026-07-28+) initialize is a removed method: skip the eager + // params deserialization (whose required properties would throw on an arbitrary + // payload) and let the session's protocol boundary reject the request with + // Method not found. + if (request.Method == RequestMethods.Initialize && + !McpProtocolVersions.RequiresPerRequestMetadata(message.Context.ProtocolVersion)) { var initializeRequest = JsonSerializer.Deserialize(request.Params, McpJsonUtilities.JsonContext.Default.InitializeRequestParams); await parentTransport.HandleInitializeRequestAsync(initializeRequest).ConfigureAwait(false); @@ -67,32 +76,117 @@ public async ValueTask HandlePostAsync(JsonRpcMessage message, Cancellatio return false; } + CancellationTokenSource? deferredFlushCts = null; + Task? deferredFlushTask = null; + bool deferHeaderFlush = false; using (await _messageLock.LockAsync(cancellationToken).ConfigureAwait(false)) { var primingItem = await TryStartSseEventStreamAsync(_pendingRequest).ConfigureAwait(false); if (primingItem.HasValue) { + await NotifyResponseStartingAsync(firstMessage: null).ConfigureAwait(false); await _httpSseWriter.WriteAsync(primingItem.Value, cancellationToken).ConfigureAwait(false); } - else + else if (onResponseStarting is null) { // If there's no priming write, flush the stream to ensure HTTP response headers are // sent to the client now that the server is ready to process the request. // This prevents HttpClient timeout for long-running requests. await responseStream.FlushAsync(cancellationToken).ConfigureAwait(false); } + else + { + deferHeaderFlush = true; + } // Ensure that we've sent the priming event before processing the incoming request. await parentTransport.MessageWriter.WriteAsync(message, cancellationToken).ConfigureAwait(false); } - // Wait for the response to be written before returning from the handler. - // This keeps the HTTP response open until the final response message is sent. - await _httpResponseTcs.Task.WaitAsync(cancellationToken).ConfigureAwait(false); + if (deferHeaderFlush) + { + // Defer the flush (and the header commit it implies) so the callback can still choose + // the HTTP status line for an immediate JSON-RPC error. Start the bounded grace period + // only after the request has been queued for dispatch. + deferredFlushCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken); + deferredFlushTask = DeferredHeaderFlushAsync(deferredFlushCts.Token); + } + + try + { + // Wait for the response to be written before returning from the handler. + // This keeps the HTTP response open until the final response message is sent. + await _httpResponseTcs.Task.WaitAsync(cancellationToken).ConfigureAwait(false); + } + finally + { + if (deferredFlushCts is not null) + { + deferredFlushCts.Cancel(); + await deferredFlushTask!.ConfigureAwait(false); + deferredFlushCts.Dispose(); + } + } return true; } + /// + /// Bounds the deferred header flush: after a short grace window, flushes the response headers + /// if no response message has been written yet. Immediate rejections land well inside the + /// window, so the response-starting callback can still map their JSON-RPC error codes onto the + /// HTTP status line; a handler that runs longer commits the headers here so clients see them + /// promptly (long-running tool calls must not trip HttpClient's response timeout). + /// + private async Task DeferredHeaderFlushAsync(CancellationToken cancellationToken) + { + try + { + await Task.Delay(DeferredHeaderFlushGrace, cancellationToken).ConfigureAwait(false); + using var _ = await _messageLock.LockAsync(cancellationToken).ConfigureAwait(false); + if (!_httpResponseStarted && !_httpResponseCompleted) + { + await NotifyResponseStartingAsync(firstMessage: null).ConfigureAwait(false); + await responseStream.FlushAsync(cancellationToken).ConfigureAwait(false); + } + } + catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) + { + // The response was written or the request ended before the grace window elapsed. + } + catch (Exception ex) + { + // Surface the failure to the awaiting HandlePostAsync when possible. If the response + // future has already been resolved (the response started or completed on another path), + // TrySetException is a no-op, so log here to keep the deferred-flush failure diagnosable. + if (!_httpResponseTcs.TrySetException(ex)) + { + LogDeferredHeaderFlushFailed(ex); + } + } + } + + /// How long the response-header flush may be deferred waiting for the first response message. + internal static readonly TimeSpan DeferredHeaderFlushGrace = TimeSpan.FromMilliseconds(250); + + /// + /// Invokes the response-starting callback exactly once, immediately before the first write to + /// the HTTP response stream, so the HTTP application can still set the response status line. + /// + private async ValueTask NotifyResponseStartingAsync(JsonRpcMessage? firstMessage) + { + if (_httpResponseStarted) + { + return; + } + + _httpResponseStarted = true; + if (onResponseStarting is not null) + { + await onResponseStarting(firstMessage).ConfigureAwait(false); + } + } + public async Task SendMessageAsync(JsonRpcMessage message, CancellationToken cancellationToken = default) { Throw.IfNull(message); @@ -128,6 +222,7 @@ public async Task SendMessageAsync(JsonRpcMessage message, CancellationToken can try { + await NotifyResponseStartingAsync(message).ConfigureAwait(false); await _httpSseWriter.WriteAsync(item, cancellationToken).ConfigureAwait(false); } catch (Exception ex) when (!cancellationToken.IsCancellationRequested) @@ -171,12 +266,15 @@ public async ValueTask EnablePollingAsync(TimeSpan retryInterval, CancellationTo // Write to the response stream if it still exists. if (!_httpResponseCompleted) { + await NotifyResponseStartingAsync(firstMessage: null).ConfigureAwait(false); await _httpSseWriter.WriteAsync(primingItem, cancellationToken).ConfigureAwait(false); } // Set the mode to 'Polling' so that the replay stream ends as soon as all available messages have been sent. // This prevents the client from immediately establishing another long-lived connection. +#pragma warning disable MCP9006 // Stateful Streamable HTTP resumability types are obsolete but still wired up internally. await _storeSseWriter.SetModeAsync(SseEventStreamMode.Polling, cancellationToken).ConfigureAwait(false); +#pragma warning restore MCP9006 // Signal completion so HandlePostAsync can return. _httpResponseTcs.TrySetResult(true); @@ -244,4 +342,7 @@ public async ValueTask DisposeAsync() [LoggerMessage(Level = LogLevel.Warning, Message = "Failed to dispose SSE event stream writer.")] private partial void LogStoreStreamDisposalFailed(Exception exception); + + [LoggerMessage(Level = LogLevel.Warning, Message = "Failed to flush deferred Streamable HTTP response headers.")] + private partial void LogDeferredHeaderFlushFailed(Exception exception); } diff --git a/src/ModelContextProtocol.Core/Server/StreamableHttpServerTransport.cs b/src/ModelContextProtocol.Core/Server/StreamableHttpServerTransport.cs index 71c366e83..f143eaaa7 100644 --- a/src/ModelContextProtocol.Core/Server/StreamableHttpServerTransport.cs +++ b/src/ModelContextProtocol.Core/Server/StreamableHttpServerTransport.cs @@ -40,11 +40,13 @@ public sealed partial class StreamableHttpServerTransport : ITransport private readonly ILogger _logger; private SseEventWriter? _httpSseWriter; +#pragma warning disable MCP9006 // Stateful Streamable HTTP resumability types are obsolete but still wired up internally. private ISseEventStreamWriter? _storeSseWriter; +#pragma warning restore MCP9006 private TaskCompletionSource? _httpResponseTcs; private string? _negotiatedProtocolVersion; private bool _getHttpRequestStarted; - private bool _getHttpResponseCompleted; + private bool _disposed; /// /// Initializes a new instance of the class. @@ -80,6 +82,7 @@ public StreamableHttpServerTransport(ILoggerFactory? loggerFactory = null) /// Gets or sets the event store for resumability support. /// When set, events are stored and can be replayed when clients reconnect with a Last-Event-ID header. /// + [Obsolete(Obsoletions.LegacyStatefulHttp_Message, DiagnosticId = Obsoletions.LegacyStatefulHttp_DiagnosticId, UrlFormat = Obsoletions.LegacyStatefulHttp_Url)] public ISseEventStreamStore? EventStreamStore { get; init; } /// @@ -122,7 +125,7 @@ public async ValueTask HandleInitializeRequestAsync(InitializeRequestParams? ini /// to the SSE response stream until cancellation is requested or the transport is disposed. /// /// The response stream to write MCP JSON-RPC messages as SSE events to. - /// The to monitor for cancellation requests. The default is . + /// The to monitor for cancellation requests. /// A task representing the send loop that writes JSON-RPC messages to the SSE response stream. /// is . /// @@ -137,33 +140,53 @@ public async Task HandleGetRequestAsync(Stream sseResponseStream, CancellationTo throw new InvalidOperationException("GET requests are not supported in stateless mode."); } - using (await _unsolicitedMessageLock.LockAsync(cancellationToken).ConfigureAwait(false)) + try { - if (_getHttpRequestStarted) + using (await _unsolicitedMessageLock.LockAsync(cancellationToken).ConfigureAwait(false)) { - throw new InvalidOperationException("Session resumption is not yet supported. Please start a new session."); - } + if (_getHttpRequestStarted) + { + throw new InvalidOperationException("Session resumption is not yet supported. Please start a new session."); + } - _getHttpRequestStarted = true; - _httpSseWriter = new SseEventWriter(sseResponseStream); - _httpResponseTcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _storeSseWriter = await TryCreateEventStreamAsync(streamId: UnsolicitedMessageStreamId, cancellationToken).ConfigureAwait(false); - if (_storeSseWriter is not null) - { - var primingItem = await _storeSseWriter.WriteEventAsync(SseItem.Prime(), cancellationToken).ConfigureAwait(false); - await _httpSseWriter.WriteAsync(primingItem, cancellationToken).ConfigureAwait(false); + _getHttpRequestStarted = true; + _httpSseWriter = new SseEventWriter(sseResponseStream); + _httpResponseTcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + _storeSseWriter = await TryCreateEventStreamAsync(streamId: UnsolicitedMessageStreamId, cancellationToken).ConfigureAwait(false); + if (_storeSseWriter is not null) + { + var primingItem = await _storeSseWriter.WriteEventAsync(SseItem.Prime(), cancellationToken).ConfigureAwait(false); + await _httpSseWriter.WriteAsync(primingItem, cancellationToken).ConfigureAwait(false); + } + else + { + // If there's no priming write, flush the stream to ensure HTTP response headers are + // sent to the client now that the transport is ready to accept messages via SendMessageAsync. + await sseResponseStream.FlushAsync(cancellationToken).ConfigureAwait(false); + } } - else + + // Wait for the response to be written before returning from the handler. + // This keeps the HTTP response open until the final response message is sent. + await _httpResponseTcs.Task.WaitAsync(cancellationToken).ConfigureAwait(false); + } + finally + { + // Release the SseEventWriter's reference to the response stream promptly when the GET + // request ends, regardless of how it exits. Otherwise the response stream (and the + // underlying Kestrel connection and associated memory pool buffers) remains pinned + // in memory until the session itself is disposed (via explicit DELETE or idle timeout). + // Clients that disconnect without sending DELETE — common with long-lived SSE — would + // otherwise accumulate significant unmanaged memory per session during that interval. + using (await _unsolicitedMessageLock.LockAsync(CancellationToken.None).ConfigureAwait(false)) { - // If there's no priming write, flush the stream to ensure HTTP response headers are - // sent to the client now that the transport is ready to accept messages via SendMessageAsync. - await sseResponseStream.FlushAsync(cancellationToken).ConfigureAwait(false); + if (_httpSseWriter is { } writer) + { + _httpSseWriter = null; + writer.Dispose(); + } } } - - // Wait for the response to be written before returning from the handler. - // This keeps the HTTP response open until the final response message is sent. - await _httpResponseTcs.Task.WaitAsync(cancellationToken).ConfigureAwait(false); } /// @@ -184,12 +207,39 @@ public async Task HandleGetRequestAsync(Stream sseResponseStream, CancellationTo /// If an authenticated sent the message, that can be included in the . /// No other part of the context should be set. /// - public async Task HandlePostRequestAsync(JsonRpcMessage message, Stream responseStream, CancellationToken cancellationToken = default) + public Task HandlePostRequestAsync(JsonRpcMessage message, Stream responseStream, CancellationToken cancellationToken = default) + => HandlePostRequestAsync(message, responseStream, onResponseStarting: null, cancellationToken); + + /// + /// Handles a Streamable HTTP POST request, processing the JSON-RPC message and writing any + /// JSON-RPC responses to the response stream. + /// This overload additionally reports the first JSON-RPC message written to the response via + /// , before any response bytes are written, so the HTTP + /// application can still choose the response status line (SEP-2575 maps some JSON-RPC error + /// codes to HTTP statuses). When is provided, the eager + /// response-header flush that normally precedes request processing is deferred until that first + /// message; the callback receives when the first write is not a JSON-RPC + /// message (e.g. a resumability priming event). + /// The status line can only be influenced by the FIRST write: when a handler streams a + /// notification (e.g. progress) before failing, or runs past the transport's bounded + /// header-flush grace window, the status is already committed and a later JSON-RPC error + /// rides the committed status. + /// + /// The JSON-RPC message to process. + /// The response stream to write any JSON-RPC responses to. + /// Callback invoked once, immediately before the first write to . + /// The to monitor for cancellation requests. The default is . + /// + /// if data was written to the response body. + /// if nothing was written because the request body did not contain any messages to respond to. + /// + /// or is . + public async Task HandlePostRequestAsync(JsonRpcMessage message, Stream responseStream, Func? onResponseStarting, CancellationToken cancellationToken) { Throw.IfNull(message); Throw.IfNull(responseStream); - var postTransport = new StreamableHttpPostTransport(this, responseStream, _transportDisposedCts.Token, _logger); + var postTransport = new StreamableHttpPostTransport(this, responseStream, _transportDisposedCts.Token, _logger, onResponseStarting); using var postCts = CancellationTokenSource.CreateLinkedTokenSource(_transportDisposedCts.Token, cancellationToken); await using (postTransport.ConfigureAwait(false)) { @@ -201,6 +251,34 @@ public async Task HandlePostRequestAsync(JsonRpcMessage message, Stream re } /// + /// + /// + /// This method sends server-to-client messages via the standalone SSE stream opened by an + /// optional HTTP GET request (see ). + /// + /// + /// This is generally the wrong channel for server-to-client requests. Requests + /// sent via the GET stream depend on the client keeping a long-lived GET open, have no per-request + /// correlation to a caller, and race with GET startup and teardown. When called from inside a + /// tool, prompt, or resource handler, use the instance available via + /// RequestContext instead — it routes through the originating POST response stream via + /// , which is always open for the duration of + /// the request. A diagnostic is emitted whenever a + /// is sent through this method. + /// + /// + /// If no GET SSE stream has yet been opened on this session, behavior depends on the message kind: + /// messages throw because the + /// awaiting caller has no way to receive a response; messages are + /// dropped (notifications are best-effort and the spec does not require clients to issue a GET) + /// and a diagnostic is logged; other messages are dropped and a + /// diagnostic is logged. + /// + /// + /// + /// is , or is a + /// and no GET SSE stream has been opened on this session. + /// public async Task SendMessageAsync(JsonRpcMessage message, CancellationToken cancellationToken = default) { Throw.IfNull(message); @@ -214,28 +292,50 @@ public async Task SendMessageAsync(JsonRpcMessage message, CancellationToken can if (!_getHttpRequestStarted) { - // Clients are not required to make a GET request for unsolicited messages. - // If no GET request has been made, drop the message. - return; + switch (message) + { + case JsonRpcRequest request: + throw new InvalidOperationException( + $"Cannot send server-to-client JSON-RPC request '{request.Method}' because no GET SSE stream has been opened on this session " + + $"(SessionId: '{SessionId}'). " + + "Inside a tool, prompt, or resource handler, use the IMcpServer instance from RequestContext (or any IMcpServer obtained via DI from a request-scoped service provider) so the request is routed through the originating POST response stream via JsonRpcMessageContext.RelatedTransport. " + + "The standalone GET SSE stream is optional for clients and is not a reliable channel for server-to-client requests."); + + case JsonRpcNotification notification: + // Clients are not required to make a GET request for unsolicited messages. + // If no GET request has been made, drop the notification (best-effort). + LogNotificationDroppedNoGetStream(notification.Method, SessionId ?? string.Empty); + return; + + default: + // JsonRpcResponse / JsonRpcError generally flow through the originating POST response + // stream, so receiving one here without a GET is unexpected. Log loudly and drop. + LogMessageDroppedNoGetStream(message.GetType().Name, GetMessageId(message), SessionId ?? string.Empty); + return; + } + } + + if (message is JsonRpcRequest openRequest) + { + LogServerRequestOverGetStream(openRequest.Method, SessionId ?? string.Empty); } - Debug.Assert(_httpSseWriter is not null); Debug.Assert(_httpResponseTcs is not null); var item = SseItem.Message(message); if (_storeSseWriter is not null) { + // Always record the message in the event store (if configured) — even when the GET + // response stream is gone — so a reconnecting client can replay it via Last-Event-ID. item = await _storeSseWriter.WriteEventAsync(item, cancellationToken).ConfigureAwait(false); } - if (!_getHttpResponseCompleted) + if (_httpSseWriter is { } writer) { - // Only write the message to the response if the response has not completed. - try { - await _httpSseWriter!.WriteAsync(item, cancellationToken).ConfigureAwait(false); + await writer.WriteAsync(item, cancellationToken).ConfigureAwait(false); } catch (Exception ex) when (!cancellationToken.IsCancellationRequested) { @@ -244,17 +344,20 @@ public async Task SendMessageAsync(JsonRpcMessage message, CancellationToken can } } + private static string GetMessageId(JsonRpcMessage message) => + message is JsonRpcMessageWithId withId ? withId.Id.ToString() : string.Empty; + /// public async ValueTask DisposeAsync() { using var _ = await _unsolicitedMessageLock.LockAsync().ConfigureAwait(false); - if (_getHttpResponseCompleted) + if (_disposed) { return; } - _getHttpResponseCompleted = true; + _disposed = true; try { @@ -266,7 +369,11 @@ public async ValueTask DisposeAsync() try { _httpResponseTcs?.TrySetResult(true); - _httpSseWriter?.Dispose(); + if (_httpSseWriter is { } writer) + { + _httpSseWriter = null; + writer.Dispose(); + } if (_storeSseWriter is not null) { @@ -280,6 +387,7 @@ public async ValueTask DisposeAsync() } } +#pragma warning disable MCP9006 // Stateful Streamable HTTP resumability types are obsolete but still wired up internally. internal async ValueTask TryCreateEventStreamAsync(string streamId, CancellationToken cancellationToken) { if (EventStreamStore is null || !McpSessionHandler.SupportsPrimingEvent(_negotiatedProtocolVersion)) @@ -300,4 +408,19 @@ public async ValueTask DisposeAsync() return sseEventStreamWriter; } +#pragma warning restore MCP9006 + + [LoggerMessage(Level = LogLevel.Warning, + Message = "Sending server-to-client JSON-RPC request '{Method}' over the standalone GET SSE stream (SessionId: '{SessionId}'). " + + "Consider using the IMcpServer instance from RequestContext inside a tool, prompt, or resource handler so the request is routed through the originating POST response stream via JsonRpcMessageContext.RelatedTransport, which is more reliable than the optional GET SSE stream.")] + private partial void LogServerRequestOverGetStream(string method, string sessionId); + + [LoggerMessage(Level = LogLevel.Debug, + Message = "Dropping server-to-client JSON-RPC notification '{Method}' because no GET SSE stream has been opened on this session (SessionId: '{SessionId}').")] + private partial void LogNotificationDroppedNoGetStream(string method, string sessionId); + + [LoggerMessage(Level = LogLevel.Warning, + Message = "Dropping unexpected server-to-client {MessageType} (Id: '{MessageId}') because no GET SSE stream has been opened on this session (SessionId: '{SessionId}'). " + + "Responses normally flow through the originating POST response stream via JsonRpcMessageContext.RelatedTransport.")] + private partial void LogMessageDroppedNoGetStream(string messageType, string messageId, string sessionId); } diff --git a/src/ModelContextProtocol.Core/Server/TaskExecutionContext.cs b/src/ModelContextProtocol.Core/Server/TaskExecutionContext.cs deleted file mode 100644 index fc45835c4..000000000 --- a/src/ModelContextProtocol.Core/Server/TaskExecutionContext.cs +++ /dev/null @@ -1,47 +0,0 @@ -namespace ModelContextProtocol.Server; - -/// -/// Represents the execution context for a task being executed by the server. -/// This context flows with async execution and enables automatic task status updates. -/// -internal sealed class TaskExecutionContext -{ - /// - /// Gets the AsyncLocal instance used to track the current task execution context. - /// - private static readonly AsyncLocal s_current = new(); - - /// - /// Gets or sets the current task execution context for the executing async flow. - /// - public static TaskExecutionContext? Current - { - get => s_current.Value; - set => s_current.Value = value; - } - - /// - /// Gets the task ID of the currently executing task. - /// - public required string TaskId { get; init; } - - /// - /// Gets the session ID associated with the task. - /// - public string? SessionId { get; init; } - - /// - /// Gets the task store used to persist task state. - /// - public required IMcpTaskStore TaskStore { get; init; } - - /// - /// Gets whether task status notifications should be sent. - /// - public bool SendNotifications { get; init; } - - /// - /// Gets or sets the function to call when sending a task status notification. - /// - public Func? NotifyTaskStatusFunc { get; init; } -} diff --git a/src/ModelContextProtocol.Core/Server/ToolCallLifecycle.cs b/src/ModelContextProtocol.Core/Server/ToolCallLifecycle.cs new file mode 100644 index 000000000..5cb6d4754 --- /dev/null +++ b/src/ModelContextProtocol.Core/Server/ToolCallLifecycle.cs @@ -0,0 +1,8 @@ +using ModelContextProtocol.Protocol; + +namespace ModelContextProtocol.Server; + +internal sealed record ToolCallLifecycle( + CallToolResult? Result, + Exception? Exception, + bool CancellationRequested); diff --git a/src/ModelContextProtocol.Core/UnsupportedProtocolVersionException.cs b/src/ModelContextProtocol.Core/UnsupportedProtocolVersionException.cs new file mode 100644 index 000000000..72ba8906d --- /dev/null +++ b/src/ModelContextProtocol.Core/UnsupportedProtocolVersionException.cs @@ -0,0 +1,74 @@ +using ModelContextProtocol.Protocol; +using System.Diagnostics.CodeAnalysis; +using System.Text.Json; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol; + +/// +/// Represents an exception used to signal that a request's declared protocol version is not supported by the server. +/// +/// +/// Introduced by the 2026-07-28 protocol revision (SEP-2575). Servers throw this exception when they cannot process +/// a request because the per-request _meta/io.modelcontextprotocol/protocolVersion (or the equivalent +/// transport-level header) names a version the server does not implement. The exception is converted to a +/// JSON-RPC error response with code (-32022) and +/// a payload. +/// +public sealed class UnsupportedProtocolVersionException : McpProtocolException +{ + /// + /// Initializes a new instance of the class. + /// + /// The protocol version the client requested. + /// The protocol versions the server supports. + /// A human-readable description of the error. If , a default message is used. + public UnsupportedProtocolVersionException(string requested, IEnumerable supported, string? message = null) + : base(message ?? $"Unsupported protocol version '{requested}'.", McpErrorCode.UnsupportedProtocolVersion) + { + Throw.IfNull(requested); + Throw.IfNull(supported); + + Requested = requested; + Supported = new List(supported); + } + + /// Gets the protocol version the client requested. + public string Requested { get; } + + /// Gets the protocol versions the server supports. + public IReadOnlyList Supported { get; } + + internal JsonNode CreateErrorDataNode() + { + var payload = new UnsupportedProtocolVersionErrorData + { + Requested = Requested, + Supported = (IList)Supported, + }; + + return JsonSerializer.SerializeToNode(payload, McpJsonUtilities.JsonContext.Default.UnsupportedProtocolVersionErrorData)!; + } + + internal static bool TryCreateFromError( + string formattedMessage, + JsonRpcErrorDetail detail, + [NotNullWhen(true)] out UnsupportedProtocolVersionException? exception) + { + exception = null; + + if (detail.Data is not JsonElement dataElement || dataElement.ValueKind is not JsonValueKind.Object) + { + return false; + } + + var payload = dataElement.Deserialize(McpJsonUtilities.JsonContext.Default.UnsupportedProtocolVersionErrorData); + if (payload is null) + { + return false; + } + + exception = new UnsupportedProtocolVersionException(payload.Requested, payload.Supported, formattedMessage); + return true; + } +} diff --git a/src/ModelContextProtocol.Extensions.Apps/ModelContextProtocol.Extensions.Apps.csproj b/src/ModelContextProtocol.Extensions.Apps/ModelContextProtocol.Extensions.Apps.csproj new file mode 100644 index 000000000..604d7d824 --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Apps/ModelContextProtocol.Extensions.Apps.csproj @@ -0,0 +1,42 @@ + + + + net10.0;net9.0;net8.0;netstandard2.0 + true + true + ModelContextProtocol.Extensions.Apps + MCP Apps extension for building interactive UI applications that render inside MCP hosts. + README.md + + $(NoWarn);MCPEXP001;MCPEXP003 + + + + true + + + + + $(NoWarn);CS0436 + + + + + + + + + + + + + + + + + + + + + diff --git a/src/ModelContextProtocol.Extensions.Apps/Server/McpAppUiAttribute.cs b/src/ModelContextProtocol.Extensions.Apps/Server/McpAppUiAttribute.cs new file mode 100644 index 000000000..2a682b8c6 --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Apps/Server/McpAppUiAttribute.cs @@ -0,0 +1,59 @@ +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.Diagnostics.CodeAnalysis; + +namespace ModelContextProtocol.Extensions.Apps; + +/// +/// Specifies MCP Apps UI metadata for a tool method. +/// +/// +/// +/// Apply this attribute alongside to associate an MCP Apps +/// UI resource with the tool. When processed by +/// or , it populates the +/// structured _meta.ui object in the tool's metadata. +/// +/// +/// Explicit Meta["ui"] set via or a raw +/// [McpMeta("ui", ...)] attribute takes precedence over this attribute: if the tool +/// already has a ui key in , this attribute is ignored. +/// +/// +/// +/// +/// [McpServerTool] +/// [McpAppUi(ResourceUri = "ui://weather/view.html")] +/// [Description("Get current weather for a location")] +/// public string GetWeather(string location) => ...; +/// +/// // Restrict visibility to model only: +/// [McpServerTool] +/// [McpAppUi(ResourceUri = "ui://weather/view.html", Visibility = [McpUiToolVisibility.Model])] +/// public string GetWeatherModelOnly(string location) => ...; +/// +/// +[AttributeUsage(AttributeTargets.Method)] +[Experimental(Experimentals.Apps_DiagnosticId, UrlFormat = Experimentals.Apps_Url)] +public sealed class McpAppUiAttribute : Attribute +{ + /// + /// Gets or sets the URI of the UI resource associated with this tool. + /// + /// + /// This should be a ui:// URI pointing to the HTML resource registered + /// with the server (e.g., "ui://weather/view.html"). + /// + public string? ResourceUri { get; set; } + + /// + /// Gets or sets the visibility of the tool, controlling which principals can invoke it. + /// + /// + /// + /// Allowed values are and . + /// When or empty, the tool is visible to both the model and the app (the default). + /// + /// + public string[]? Visibility { get; set; } +} diff --git a/src/ModelContextProtocol.Extensions.Apps/Server/McpApps.cs b/src/ModelContextProtocol.Extensions.Apps/Server/McpApps.cs new file mode 100644 index 000000000..53de40759 --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Apps/Server/McpApps.cs @@ -0,0 +1,265 @@ +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.Diagnostics.CodeAnalysis; +using System.Text.Json; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.Extensions.Apps; + +/// +/// Provides constants and helper methods for building MCP Apps-enabled servers. +/// +/// +/// +/// MCP Apps is an extension to the Model Context Protocol that enables MCP servers to deliver +/// interactive user interfaces — dashboards, forms, visualizations, and more — directly inside +/// conversational AI clients. +/// +/// +/// Use the constants in this class when populating the extensions capability and the +/// _meta field of tools and resources. Use to check whether +/// the connected client supports the MCP Apps extension. +/// +/// +/// Use to set the _meta.ui metadata on a tool, or +/// to automatically process +/// instances on tools created from methods. +/// +/// +[Experimental(Experimentals.Apps_DiagnosticId, UrlFormat = Experimentals.Apps_Url)] +public static class McpApps +{ + /// + /// The MIME type used for MCP App HTML resources. + /// + /// + /// This MIME type should be used when registering UI resources with + /// text/html;profile=mcp-app to indicate they are MCP App resources. + /// + public const string HtmlMimeType = "text/html;profile=mcp-app"; + + /// + /// The extension identifier used for MCP Apps capability negotiation. + /// + /// + /// This key is used in the and + /// dictionaries to advertise support for + /// the MCP Apps extension. + /// + public const string ExtensionId = "io.modelcontextprotocol/ui"; + + /// + /// Gets the configured with source-generated metadata + /// for MCP Apps extension types. + /// + /// + /// Use these options when serializing or deserializing MCP Apps types such as + /// , , and . + /// + public static JsonSerializerOptions SerializerOptions { get; } = CreateSerializerOptions(); + + private static JsonSerializerOptions CreateSerializerOptions() + { + var options = new JsonSerializerOptions(McpJsonUtilities.DefaultOptions); + options.TypeInfoResolverChain.Insert(0, McpAppsJsonContext.Default); + options.MakeReadOnly(); + return options; + } + + /// + /// Gets the MCP Apps client capability, if advertised by the connected client. + /// + /// The client capabilities received during the MCP initialize handshake. + /// + /// A instance if the client advertises support for the MCP Apps extension; + /// otherwise, . + /// + /// + /// Use this method to determine whether the connected client supports the MCP Apps extension + /// and to read the client's supported MIME types. + /// + public static McpUiClientCapabilities? GetUiCapability(ClientCapabilities? capabilities) + { + if (capabilities?.Extensions is not { } extensions || + !extensions.TryGetValue(ExtensionId, out var value)) + { + return null; + } + + // Handle the case where the value was set programmatically (e.g. in tests + // or a non-JSON code path) rather than deserialized from the handshake. + if (value is McpUiClientCapabilities uiCapabilities) + { + return uiCapabilities; + } + + if (value is JsonElement element) + { + // Guard against malformed extension values (e.g. a bare string or number) + // that would throw JsonException during deserialization. Return null + // consistently for any non-object value, matching the other failure modes. + if (element.ValueKind is JsonValueKind.Null or JsonValueKind.Undefined) + { + return null; + } + + if (element.ValueKind != JsonValueKind.Object) + { + return null; + } + + return JsonSerializer.Deserialize(element, McpAppsJsonContext.Default.McpUiClientCapabilities); + } + + return null; + } + + /// + /// Sets the MCP Apps UI metadata on a tool's property. + /// + /// The tool to set the UI metadata on. + /// The UI metadata to apply. + /// The same instance, for chaining. + /// + /// + /// This method sets the ui key in the tool's object. + /// If a ui key is already present in , it is not overwritten. + /// + /// + /// or is . + public static McpServerTool SetAppUi(McpServerTool tool, McpUiToolMeta appUi) + { +#if NET + ArgumentNullException.ThrowIfNull(tool); + ArgumentNullException.ThrowIfNull(appUi); +#else + if (tool is null) throw new ArgumentNullException(nameof(tool)); + if (appUi is null) throw new ArgumentNullException(nameof(appUi)); +#endif + + var protocolTool = tool.ProtocolTool; + protocolTool.Meta ??= new JsonObject(); + + if (!protocolTool.Meta.ContainsKey("ui")) + { + var uiNode = JsonSerializer.SerializeToNode(appUi, McpAppsJsonContext.Default.McpUiToolMeta); + if (uiNode is not null) + { + protocolTool.Meta["ui"] = uiNode; + } + } + + return tool; + } + + /// + /// Sets the MCP Apps UI metadata on a resource's property. + /// + /// The resource to set the UI metadata on. + /// The UI metadata to apply. + /// The same instance, for chaining. + /// + /// + /// This method sets the ui key in the resource's object. + /// If a ui key is already present in , it is not overwritten. + /// + /// + /// or is . + public static McpServerResource SetResourceUi(McpServerResource resource, McpUiResourceMeta resourceUi) + { +#if NET + ArgumentNullException.ThrowIfNull(resource); + ArgumentNullException.ThrowIfNull(resourceUi); +#else + if (resource is null) throw new ArgumentNullException(nameof(resource)); + if (resourceUi is null) throw new ArgumentNullException(nameof(resourceUi)); +#endif + + var protocolResource = resource.ProtocolResourceTemplate; + protocolResource.Meta ??= new JsonObject(); + + if (!protocolResource.Meta.ContainsKey("ui")) + { + var uiNode = JsonSerializer.SerializeToNode(resourceUi, McpAppsJsonContext.Default.McpUiResourceMeta); + if (uiNode is not null) + { + protocolResource.Meta["ui"] = uiNode; + } + } + + return resource; + } + + /// + /// Processes a collection of tools, applying metadata to any + /// tool whose underlying method has the attribute. + /// + /// The tools to process. + /// The same enumerable, for chaining. + /// + /// + /// For each tool that has a in its , + /// this method sets the ui key in the tool's if not already present. + /// + /// + /// If already contains a ui key (e.g., set explicitly via + /// ), the attribute is not applied. + /// + /// + /// is . + public static IEnumerable ApplyAppUiAttributes(IEnumerable tools) + { +#if NET + ArgumentNullException.ThrowIfNull(tools); +#else + if (tools is null) throw new ArgumentNullException(nameof(tools)); +#endif + + foreach (var tool in tools) + { + ApplyAppUiAttributes(tool); + } + + return tools; + } + + /// + /// Processes a single tool, applying metadata if the tool's + /// underlying method has the attribute. + /// + /// The tool to process. + /// The same instance, for chaining. + /// + /// + /// If the tool has a in its , + /// this method sets the ui key in the tool's if not already present. + /// + /// + /// is . + public static McpServerTool ApplyAppUiAttributes(McpServerTool tool) + { +#if NET + ArgumentNullException.ThrowIfNull(tool); +#else + if (tool is null) throw new ArgumentNullException(nameof(tool)); +#endif + + // Look for McpAppUiAttribute in tool metadata (attributes from the method) + foreach (var metadataItem in tool.Metadata) + { + if (metadataItem is McpAppUiAttribute appUiAttr) + { + var meta = new McpUiToolMeta + { + ResourceUri = appUiAttr.ResourceUri, + Visibility = appUiAttr.Visibility, + }; + + SetAppUi(tool, meta); + break; + } + } + + return tool; + } +} diff --git a/src/ModelContextProtocol.Extensions.Apps/Server/McpAppsBuilderExtensions.cs b/src/ModelContextProtocol.Extensions.Apps/Server/McpAppsBuilderExtensions.cs new file mode 100644 index 000000000..a68d8fe50 --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Apps/Server/McpAppsBuilderExtensions.cs @@ -0,0 +1,71 @@ +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Options; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.Diagnostics.CodeAnalysis; + +namespace ModelContextProtocol.Extensions.Apps; + +/// +/// Extension methods for to enable MCP Apps support. +/// +[Experimental(Experimentals.Apps_DiagnosticId, UrlFormat = Experimentals.Apps_Url)] +public static class McpAppsBuilderExtensions +{ + /// + /// Enables MCP Apps support by automatically processing on registered tools. + /// + /// The server builder. + /// The builder provided in . + /// + /// + /// Call this method after registering tools (e.g., after WithTools<T>()) to automatically + /// apply metadata to the tool's _meta.ui field. + /// + /// + /// Tools that already have a ui key in their (e.g., set explicitly + /// via ) are not modified. + /// + /// + /// + /// + /// builder.Services + /// .AddMcpServer() + /// .WithTools<MyToolType>() + /// .WithMcpApps(); + /// + /// + public static IMcpServerBuilder WithMcpApps(this IMcpServerBuilder builder) + { +#if NET + ArgumentNullException.ThrowIfNull(builder); +#else + if (builder is null) throw new ArgumentNullException(nameof(builder)); +#endif + + builder.Services.AddSingleton, McpAppsPostConfigureOptions>(); + return builder; + } + + private sealed class McpAppsPostConfigureOptions : IPostConfigureOptions + { + public void PostConfigure(string? name, McpServerOptions options) + { + // Advertise server-side MCP Apps support in capabilities. + options.Capabilities ??= new ServerCapabilities(); + options.Capabilities.Extensions ??= new Dictionary(); + if (!options.Capabilities.Extensions.ContainsKey(McpApps.ExtensionId)) + { + options.Capabilities.Extensions[McpApps.ExtensionId] = new System.Text.Json.Nodes.JsonObject(); + } + + if (options.ToolCollection is { IsEmpty: false } tools) + { + foreach (var tool in tools) + { + McpApps.ApplyAppUiAttributes(tool); + } + } + } + } +} diff --git a/src/ModelContextProtocol.Extensions.Apps/Server/McpAppsJsonContext.cs b/src/ModelContextProtocol.Extensions.Apps/Server/McpAppsJsonContext.cs new file mode 100644 index 000000000..8a03ab95d --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Apps/Server/McpAppsJsonContext.cs @@ -0,0 +1,19 @@ +using System.Text.Json; +using System.Text.Json.Serialization; + +namespace ModelContextProtocol.Extensions.Apps; + +/// +/// Provides source-generated JSON serialization metadata for MCP Apps extension types. +/// +[JsonSourceGenerationOptions( + DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull, + PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase)] +[JsonSerializable(typeof(McpUiToolMeta))] +[JsonSerializable(typeof(McpUiClientCapabilities))] +[JsonSerializable(typeof(McpUiResourceMeta))] +[JsonSerializable(typeof(McpUiResourceCsp))] +[JsonSerializable(typeof(McpUiResourcePermissions))] +internal sealed partial class McpAppsJsonContext : JsonSerializerContext +{ +} diff --git a/src/ModelContextProtocol.Extensions.Apps/Server/McpUiClientCapabilities.cs b/src/ModelContextProtocol.Extensions.Apps/Server/McpUiClientCapabilities.cs new file mode 100644 index 000000000..a446d90cb --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Apps/Server/McpUiClientCapabilities.cs @@ -0,0 +1,26 @@ +using System.Diagnostics.CodeAnalysis; +using System.Text.Json.Serialization; + +namespace ModelContextProtocol.Extensions.Apps; + +/// +/// Represents the MCP Apps capabilities advertised by a client. +/// +/// +/// +/// This object is the value associated with the "io.modelcontextprotocol/ui" key in the +/// dictionary. +/// +/// +[Experimental(Experimentals.Apps_DiagnosticId, UrlFormat = Experimentals.Apps_Url)] +public sealed class McpUiClientCapabilities +{ + /// + /// Gets or sets the list of MIME types supported by the client for MCP App UI resources. + /// + /// + /// A client that supports MCP Apps must include "text/html;profile=mcp-app" in this list. + /// + [JsonPropertyName("mimeTypes")] + public IList? MimeTypes { get; set; } +} diff --git a/src/ModelContextProtocol.Extensions.Apps/Server/McpUiResourceCsp.cs b/src/ModelContextProtocol.Extensions.Apps/Server/McpUiResourceCsp.cs new file mode 100644 index 000000000..da13efea3 --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Apps/Server/McpUiResourceCsp.cs @@ -0,0 +1,49 @@ +using System.Diagnostics.CodeAnalysis; +using System.Text.Json.Serialization; + +namespace ModelContextProtocol.Extensions.Apps; + +/// +/// Represents the Content Security Policy (CSP) domain allowlists for an MCP Apps UI resource. +/// +/// +/// +/// These allowlists are used by the MCP host to construct the Content-Security-Policy HTTP header +/// for the sandboxed iframe that hosts the UI resource. +/// +/// +/// Each list contains origins (e.g., "https://api.example.com") that are permitted for +/// the corresponding CSP directive. +/// +/// +[Experimental(Experimentals.Apps_DiagnosticId, UrlFormat = Experimentals.Apps_Url)] +public sealed class McpUiResourceCsp +{ + /// + /// Gets or sets the list of origins allowed for fetch, XMLHttpRequest, WebSocket, and EventSource + /// connections (connect-src CSP directive). + /// + [JsonPropertyName("connectDomains")] + public IList? ConnectDomains { get; set; } + + /// + /// Gets or sets the list of origins allowed for loading scripts, stylesheets, images, and fonts + /// (script-src, style-src, img-src, font-src CSP directives). + /// + [JsonPropertyName("resourceDomains")] + public IList? ResourceDomains { get; set; } + + /// + /// Gets or sets the list of origins allowed for loading nested frames + /// (frame-src CSP directive). + /// + [JsonPropertyName("frameDomains")] + public IList? FrameDomains { get; set; } + + /// + /// Gets or sets the list of allowed base URIs + /// (base-uri CSP directive). + /// + [JsonPropertyName("baseUris")] + public IList? BaseUris { get; set; } +} diff --git a/src/ModelContextProtocol.Extensions.Apps/Server/McpUiResourceMeta.cs b/src/ModelContextProtocol.Extensions.Apps/Server/McpUiResourceMeta.cs new file mode 100644 index 000000000..fcb09d86a --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Apps/Server/McpUiResourceMeta.cs @@ -0,0 +1,50 @@ +using System.Diagnostics.CodeAnalysis; +using System.Text.Json.Serialization; + +namespace ModelContextProtocol.Extensions.Apps; + +/// +/// Represents the UI metadata associated with an MCP resource in the MCP Apps extension. +/// +/// +/// This metadata is placed under the ui key in the resource's _meta object. +/// It provides Content Security Policy (CSP) configuration, sandbox permissions, CORS origin, and +/// visual boundary preferences for the UI resource served by this MCP server. +/// +[Experimental(Experimentals.Apps_DiagnosticId, UrlFormat = Experimentals.Apps_Url)] +public sealed class McpUiResourceMeta +{ + /// + /// Gets or sets the Content Security Policy configuration for this resource. + /// + /// + /// Specifies the allowed origins for network requests, resource loads, and nested frames. + /// + [JsonPropertyName("csp")] + public McpUiResourceCsp? Csp { get; set; } + + /// + /// Gets or sets the sandbox permissions for this resource. + /// + /// + /// Controls which browser sandbox features the UI resource is allowed to use. + /// + [JsonPropertyName("permissions")] + public McpUiResourcePermissions? Permissions { get; set; } + + /// + /// Gets or sets the dedicated origin domain for this resource. + /// + /// + /// When set, the host will serve the resource from this dedicated origin, + /// enabling OAuth flows and CORS without wildcard exceptions. + /// + [JsonPropertyName("domain")] + public string? Domain { get; set; } + + /// + /// Gets or sets a value indicating whether the host should render a visual border around the UI. + /// + [JsonPropertyName("prefersBorder")] + public bool? PrefersBorder { get; set; } +} diff --git a/src/ModelContextProtocol.Extensions.Apps/Server/McpUiResourcePermissions.cs b/src/ModelContextProtocol.Extensions.Apps/Server/McpUiResourcePermissions.cs new file mode 100644 index 000000000..758fee03b --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Apps/Server/McpUiResourcePermissions.cs @@ -0,0 +1,27 @@ +using System.Diagnostics.CodeAnalysis; +using System.Text.Json.Serialization; + +namespace ModelContextProtocol.Extensions.Apps; + +/// +/// Represents the sandbox permissions requested by an MCP Apps UI resource. +/// +/// +/// This maps to the allow attribute on the iframe sandbox in the MCP host. +/// Permissions are specified as standard browser iframe permission strings, +/// such as "camera", "microphone", or "geolocation". +/// +[Experimental(Experimentals.Apps_DiagnosticId, UrlFormat = Experimentals.Apps_Url)] +public sealed class McpUiResourcePermissions +{ + /// + /// Gets or sets the list of permissions granted to the sandboxed UI resource. + /// + /// + /// These correspond to values allowed in the allow attribute of an HTML iframe, + /// for example "camera", "microphone", "geolocation", + /// "clipboard-read", or "clipboard-write". + /// + [JsonPropertyName("allow")] + public IList? Allow { get; set; } +} diff --git a/src/ModelContextProtocol.Extensions.Apps/Server/McpUiToolMeta.cs b/src/ModelContextProtocol.Extensions.Apps/Server/McpUiToolMeta.cs new file mode 100644 index 000000000..44fa369c1 --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Apps/Server/McpUiToolMeta.cs @@ -0,0 +1,41 @@ +using System.Diagnostics.CodeAnalysis; +using System.Text.Json.Serialization; + +namespace ModelContextProtocol.Extensions.Apps; + +/// +/// Represents the UI metadata associated with an MCP tool in the MCP Apps extension. +/// +/// +/// +/// This metadata is placed under the ui key in the tool's _meta object. +/// It associates the tool with a UI resource (identified by a ui:// URI) and optionally +/// controls which principals (model, app) can call the tool. +/// +/// +[Experimental(Experimentals.Apps_DiagnosticId, UrlFormat = Experimentals.Apps_Url)] +public sealed class McpUiToolMeta +{ + /// + /// Gets or sets the URI of the UI resource associated with this tool. + /// + /// + /// This should be a ui:// URI pointing to the HTML resource registered + /// with the server (e.g., "ui://weather/view.html"). + /// + [JsonPropertyName("resourceUri")] + public string? ResourceUri { get; set; } + + /// + /// Gets or sets the visibility of the tool, controlling which principals can invoke it. + /// + /// + /// + /// Allowed values are ("model") and + /// ("app"). When + /// or empty, the tool is visible to both the model and the app (the default). + /// + /// + [JsonPropertyName("visibility")] + public IList? Visibility { get; set; } +} diff --git a/src/ModelContextProtocol.Extensions.Apps/Server/McpUiToolVisibility.cs b/src/ModelContextProtocol.Extensions.Apps/Server/McpUiToolVisibility.cs new file mode 100644 index 000000000..23b66a11b --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Apps/Server/McpUiToolVisibility.cs @@ -0,0 +1,25 @@ +using System.Diagnostics.CodeAnalysis; + +namespace ModelContextProtocol.Extensions.Apps; + +/// +/// Provides well-known visibility values for . +/// +/// +/// Use these constants to specify which principals can invoke a tool in the MCP Apps extension. +/// When is or empty, the tool +/// is visible to both the model and the app by default. +/// +[Experimental(Experimentals.Apps_DiagnosticId, UrlFormat = Experimentals.Apps_Url)] +public static class McpUiToolVisibility +{ + /// + /// Indicates that the tool can be invoked by the AI model. + /// + public const string Model = "model"; + + /// + /// Indicates that the tool can be invoked by the UI app (iframe). + /// + public const string App = "app"; +} diff --git a/src/ModelContextProtocol.Extensions.Tasks/Client/McpTasksClientExtensions.cs b/src/ModelContextProtocol.Extensions.Tasks/Client/McpTasksClientExtensions.cs new file mode 100644 index 000000000..833f2b250 --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Tasks/Client/McpTasksClientExtensions.cs @@ -0,0 +1,397 @@ +using ModelContextProtocol; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using System.Text.Json; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.Extensions.Tasks; + +/// +/// Extension methods for task-aware client operations. +/// +public static class McpTasksClientExtensions +{ + /// + /// Calls a tool and returns either an immediate result or a created task. + /// + public static async ValueTask> CallToolAsTaskAsync( + this McpClient client, + CallToolRequestParams requestParams, + CancellationToken cancellationToken = default) + { +#if NET + ArgumentNullException.ThrowIfNull(client); + ArgumentNullException.ThrowIfNull(requestParams); +#else + if (client is null) throw new ArgumentNullException(nameof(client)); + if (requestParams is null) throw new ArgumentNullException(nameof(requestParams)); +#endif + + var paramsWithMeta = new CallToolRequestParams + { + Name = requestParams.Name, + Arguments = requestParams.Arguments, + Meta = IsJuly2026OrLaterProtocol(client) ? GetMetaWithTaskCapability(requestParams.Meta) : requestParams.Meta, + }; + + JsonRpcRequest jsonRpcRequest = new() + { + Method = RequestMethods.ToolsCall, + Params = JsonSerializer.SerializeToNode(paramsWithMeta, McpJsonUtilities.DefaultOptions.GetTypeInfo()), + }; + + JsonRpcResponse response = await client.SendRequestAsync(jsonRpcRequest, cancellationToken).ConfigureAwait(false); + + if (response.Result is JsonObject resultObj && + resultObj.TryGetPropertyValue("resultType", out var resultTypeNode) && + string.Equals(resultTypeNode?.GetValue(), "task", StringComparison.Ordinal)) + { + var taskCreated = resultObj.Deserialize(McpTasksJsonContext.Default.CreateTaskResult) + ?? throw new JsonException("Failed to deserialize CreateTaskResult from response."); + return new ResultOrCreatedTask(taskCreated); + } + + var callToolResult = JsonSerializer.Deserialize(response.Result, McpJsonUtilities.DefaultOptions.GetTypeInfo()) + ?? throw new JsonException("Failed to deserialize CallToolResult from response."); + return new ResultOrCreatedTask(callToolResult); + } + + /// + /// Calls a tool and, if needed, polls the created task to completion. + /// + public static async ValueTask CallToolWithPollingAsync( + this McpClient client, + CallToolRequestParams requestParams, + int maxConsecutiveStuckPolls = 60, + CancellationToken cancellationToken = default) + { +#if NET + ArgumentNullException.ThrowIfNull(client); + ArgumentNullException.ThrowIfNull(requestParams); +#else + if (client is null) throw new ArgumentNullException(nameof(client)); + if (requestParams is null) throw new ArgumentNullException(nameof(requestParams)); +#endif + + var augmented = await client.CallToolAsTaskAsync(requestParams, cancellationToken).ConfigureAwait(false); + if (!augmented.IsTask) + { + return augmented.Result!; + } + + return await PollTaskToCompletionAsync(client, augmented.TaskCreated!, maxConsecutiveStuckPolls, cancellationToken).ConfigureAwait(false); + } + + /// + /// Retrieves a task by ID. + /// + public static ValueTask GetTaskAsync( + this McpClient client, + string taskId, + CancellationToken cancellationToken = default) + { +#if NET + ArgumentNullException.ThrowIfNull(client); + ArgumentNullException.ThrowIfNull(taskId); +#else + if (client is null) throw new ArgumentNullException(nameof(client)); + if (taskId is null) throw new ArgumentNullException(nameof(taskId)); +#endif + + return client.GetTaskAsync(new GetTaskRequestParams { TaskId = taskId }, cancellationToken); + } + + /// + /// Retrieves a task using explicit request parameters. + /// + public static async ValueTask GetTaskAsync( + this McpClient client, + GetTaskRequestParams requestParams, + CancellationToken cancellationToken = default) + { +#if NET + ArgumentNullException.ThrowIfNull(client); + ArgumentNullException.ThrowIfNull(requestParams); +#else + if (client is null) throw new ArgumentNullException(nameof(client)); + if (requestParams is null) throw new ArgumentNullException(nameof(requestParams)); +#endif + + ThrowIfTasksNotSupported(client, nameof(GetTaskAsync)); + requestParams = new GetTaskRequestParams + { + TaskId = requestParams.TaskId, + Meta = GetMetaWithTaskCapability(requestParams.Meta), + }; + JsonRpcRequest jsonRpcRequest = CreateTaskRequest( + TasksProtocol.MethodTasksGet, + JsonSerializer.SerializeToNode(requestParams, McpTasksJsonContext.Default.GetTaskRequestParams), + requestParams.TaskId); + + JsonRpcResponse response = await client.SendRequestAsync(jsonRpcRequest, cancellationToken).ConfigureAwait(false); + return response.Result?.Deserialize(McpTasksJsonContext.Default.GetTaskResult) + ?? throw new JsonException("Unexpected JSON result in response."); + } + + /// + /// Updates a task with input responses. + /// + public static async ValueTask UpdateTaskAsync( + this McpClient client, + UpdateTaskRequestParams requestParams, + CancellationToken cancellationToken = default) + { +#if NET + ArgumentNullException.ThrowIfNull(client); + ArgumentNullException.ThrowIfNull(requestParams); +#else + if (client is null) throw new ArgumentNullException(nameof(client)); + if (requestParams is null) throw new ArgumentNullException(nameof(requestParams)); +#endif + + ThrowIfTasksNotSupported(client, nameof(UpdateTaskAsync)); + + // Manually construct the JSON params because InputResponses is backed by an internal + // property in Core that the extension's source-gen context cannot access for serialization. + JsonObject paramsObj = new() + { + ["taskId"] = requestParams.TaskId, + ["_meta"] = GetMetaWithTaskCapability(requestParams.Meta), + }; + + if (requestParams.InputResponses is { Count: > 0 } inputResponses) + { + paramsObj["inputResponses"] = JsonSerializer.SerializeToNode( + inputResponses, + McpJsonUtilities.DefaultOptions.GetTypeInfo>()); + } + + JsonRpcRequest jsonRpcRequest = CreateTaskRequest( + TasksProtocol.MethodTasksUpdate, + paramsObj, + requestParams.TaskId); + + JsonRpcResponse response = await client.SendRequestAsync(jsonRpcRequest, cancellationToken).ConfigureAwait(false); + return response.Result?.Deserialize(McpTasksJsonContext.Default.UpdateTaskResult) + ?? new UpdateTaskResult(); + } + + /// + /// Requests task cancellation by ID. + /// + public static ValueTask CancelTaskAsync( + this McpClient client, + string taskId, + CancellationToken cancellationToken = default) + { +#if NET + ArgumentNullException.ThrowIfNull(client); + ArgumentNullException.ThrowIfNull(taskId); +#else + if (client is null) throw new ArgumentNullException(nameof(client)); + if (taskId is null) throw new ArgumentNullException(nameof(taskId)); +#endif + + return client.CancelTaskAsync(new CancelTaskRequestParams { TaskId = taskId }, cancellationToken); + } + + /// + /// Requests task cancellation using explicit request parameters. + /// + public static async ValueTask CancelTaskAsync( + this McpClient client, + CancelTaskRequestParams requestParams, + CancellationToken cancellationToken = default) + { +#if NET + ArgumentNullException.ThrowIfNull(client); + ArgumentNullException.ThrowIfNull(requestParams); +#else + if (client is null) throw new ArgumentNullException(nameof(client)); + if (requestParams is null) throw new ArgumentNullException(nameof(requestParams)); +#endif + + ThrowIfTasksNotSupported(client, nameof(CancelTaskAsync)); + requestParams = new CancelTaskRequestParams + { + TaskId = requestParams.TaskId, + Meta = GetMetaWithTaskCapability(requestParams.Meta), + }; + JsonRpcRequest jsonRpcRequest = CreateTaskRequest( + TasksProtocol.MethodTasksCancel, + JsonSerializer.SerializeToNode(requestParams, McpTasksJsonContext.Default.CancelTaskRequestParams), + requestParams.TaskId); + + JsonRpcResponse response = await client.SendRequestAsync(jsonRpcRequest, cancellationToken).ConfigureAwait(false); + return response.Result?.Deserialize(McpTasksJsonContext.Default.CancelTaskResult) + ?? new CancelTaskResult(); + } + + private static JsonRpcRequest CreateTaskRequest(string method, JsonNode? parameters, string taskId) => + new() + { + Method = method, + Params = parameters, + Context = new JsonRpcMessageContext + { + RoutingName = taskId, + }, + }; + + private static async ValueTask PollTaskToCompletionAsync( + McpClient client, + CreateTaskResult taskCreated, + int maxConsecutiveStuckPolls, + CancellationToken cancellationToken) + { + string taskId = taskCreated.TaskId; + long pollIntervalMs = taskCreated.PollIntervalMs ?? 1000; + HashSet? resolvedRequestKeys = null; + bool isFirstPoll = true; + int consecutiveStuckPolls = 0; + + while (true) + { + if (!isFirstPoll) + { + await Task.Delay(TimeSpan.FromMilliseconds(pollIntervalMs), cancellationToken).ConfigureAwait(false); + } + + isFirstPoll = false; + + var taskResult = await GetTaskAsync(client, taskId, cancellationToken).ConfigureAwait(false); + if (taskResult.PollIntervalMs is { } newInterval) + { + pollIntervalMs = newInterval; + } + + switch (taskResult) + { + case CompletedTaskResult completed: + return JsonSerializer.Deserialize(completed.Result, McpJsonUtilities.DefaultOptions.GetTypeInfo()) + ?? throw new JsonException("Failed to deserialize CallToolResult from completed task."); + + case FailedTaskResult failed: + throw new McpException($"Task '{taskId}' failed: {failed.Error}"); + + case CancelledTaskResult: + throw new OperationCanceledException($"Task '{taskId}' was cancelled by the server."); + + case InputRequiredTaskResult inputRequired: + var newRequests = new Dictionary(); + if (inputRequired.InputRequests is { } incomingRequests) + { + foreach (var kvp in incomingRequests) + { + if (resolvedRequestKeys is null || !resolvedRequestKeys.Contains(kvp.Key)) + { + newRequests[kvp.Key] = kvp.Value; + } + } + } + + if (newRequests.Count > 0) + { + consecutiveStuckPolls = 0; + + IDictionary inputResponses; + try + { + inputResponses = await client.ResolveInputRequestsAsync(newRequests, cancellationToken).ConfigureAwait(false); + } + catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) + { + throw; + } + catch + { + try + { + await CancelTaskAsync(client, taskId, CancellationToken.None).ConfigureAwait(false); + } + catch + { + } + + throw; + } + + await UpdateTaskAsync(client, new UpdateTaskRequestParams + { + TaskId = taskId, + InputResponses = inputResponses, + }, cancellationToken).ConfigureAwait(false); + + resolvedRequestKeys ??= new HashSet(StringComparer.Ordinal); + foreach (var key in inputResponses.Keys) + { + resolvedRequestKeys.Add(key); + } + } + else if (++consecutiveStuckPolls >= maxConsecutiveStuckPolls) + { + try + { + await CancelTaskAsync(client, taskId, CancellationToken.None).ConfigureAwait(false); + } + catch + { + } + + throw new McpException( + $"Task '{taskId}' has remained in '{McpTaskStatus.InputRequired}' for {maxConsecutiveStuckPolls} consecutive polls " + + "without publishing new input requests after all previously requested inputs were resolved."); + } + + break; + + case WorkingTaskResult: + consecutiveStuckPolls = 0; + break; + + default: + throw new McpException($"Unexpected task result type '{taskResult.GetType().Name}' for task '{taskId}'."); + } + } + } + + private static JsonObject GetMetaWithTaskCapability(JsonObject? existingMeta) + { + JsonObject meta = existingMeta is not null + ? (JsonObject)existingMeta.DeepClone() + : []; + + if (meta[MetaKeys.ClientCapabilities] is not JsonObject capsRoot) + { + capsRoot = []; + meta[MetaKeys.ClientCapabilities] = capsRoot; + } + + if (capsRoot["extensions"] is not JsonObject extensionsRoot) + { + extensionsRoot = []; + capsRoot["extensions"] = extensionsRoot; + } + + if (!extensionsRoot.ContainsKey(TasksProtocol.ExtensionId)) + { + extensionsRoot[TasksProtocol.ExtensionId] = new JsonObject(); + } + + return meta; + } + + private static bool IsJuly2026OrLaterProtocol(McpClient client) => + McpProtocolVersions.IsJuly2026OrLaterProtocolVersion(client.NegotiatedProtocolVersion); + + private static void ThrowIfTasksNotSupported(McpClient client, string operationName) + { + if (!IsJuly2026OrLaterProtocol(client)) + { + throw new InvalidOperationException( + $"'{operationName}' requires a newer protocol revision that supports tasks " + + $"(the '{McpProtocolVersions.July2026ProtocolVersion}' revision or later). " + + $"The negotiated protocol version is '{client.NegotiatedProtocolVersion ?? "(none)"}'."); + } + } +} diff --git a/src/ModelContextProtocol.Extensions.Tasks/McpTasksJsonContext.cs b/src/ModelContextProtocol.Extensions.Tasks/McpTasksJsonContext.cs new file mode 100644 index 000000000..13c92ee14 --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Tasks/McpTasksJsonContext.cs @@ -0,0 +1,32 @@ +using System.Text.Json.Serialization; +using ModelContextProtocol.Protocol; + +namespace ModelContextProtocol.Extensions.Tasks; + +/// +/// Provides source-generated JSON serialization metadata for MCP Tasks extension types. +/// +[JsonSourceGenerationOptions( + DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull, + PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase)] +[JsonSerializable(typeof(CreateTaskResult))] +[JsonSerializable(typeof(GetTaskRequestParams))] +[JsonSerializable(typeof(GetTaskResult))] +[JsonSerializable(typeof(WorkingTaskResult))] +[JsonSerializable(typeof(CompletedTaskResult))] +[JsonSerializable(typeof(FailedTaskResult))] +[JsonSerializable(typeof(CancelledTaskResult))] +[JsonSerializable(typeof(InputRequiredTaskResult))] +[JsonSerializable(typeof(UpdateTaskRequestParams))] +[JsonSerializable(typeof(UpdateTaskResult))] +[JsonSerializable(typeof(CancelTaskRequestParams))] +[JsonSerializable(typeof(CancelTaskResult))] +[JsonSerializable(typeof(TaskStatusNotificationParams))] +[JsonSerializable(typeof(WorkingTaskNotificationParams))] +[JsonSerializable(typeof(CompletedTaskNotificationParams))] +[JsonSerializable(typeof(FailedTaskNotificationParams))] +[JsonSerializable(typeof(CancelledTaskNotificationParams))] +[JsonSerializable(typeof(InputRequiredTaskNotificationParams))] +public sealed partial class McpTasksJsonContext : JsonSerializerContext +{ +} diff --git a/src/ModelContextProtocol.Extensions.Tasks/ModelContextProtocol.Extensions.Tasks.csproj b/src/ModelContextProtocol.Extensions.Tasks/ModelContextProtocol.Extensions.Tasks.csproj new file mode 100644 index 000000000..cfeef00f4 --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Tasks/ModelContextProtocol.Extensions.Tasks.csproj @@ -0,0 +1,50 @@ + + + + net10.0;net9.0;net8.0;netstandard2.0 + true + true + ModelContextProtocol.Extensions.Tasks + MCP Tasks extension for the .NET Model Context Protocol (MCP) SDK + README.md + + $(NoWarn);MCPEXP001;MCPEXP002 + + + + true + + + + + $(NoWarn);CS0436 + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/ModelContextProtocol.Extensions.Tasks/Protocol/CancelTaskRequestParams.cs b/src/ModelContextProtocol.Extensions.Tasks/Protocol/CancelTaskRequestParams.cs new file mode 100644 index 000000000..f4d6ff69f --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Tasks/Protocol/CancelTaskRequestParams.cs @@ -0,0 +1,30 @@ +using ModelContextProtocol.Protocol; +using System.Text.Json.Serialization; + +namespace ModelContextProtocol.Extensions.Tasks; + +/// +/// Represents the parameters for a tasks/cancel request to signal intent to cancel an in-progress task. +/// +/// +/// +/// Cancellation is cooperative: the request signals intent, and the server decides whether and when to honor it. +/// A server is not obligated to actually stop the work; it is only obligated to acknowledge the request. +/// Eventual transition to is not guaranteed. +/// +/// +/// The notifications/cancelled notification must not be used for task cancellation. +/// +/// +/// See the SEP-2663 +/// specification for details. +/// +/// +public sealed class CancelTaskRequestParams : RequestParams +{ + /// + /// Gets or sets the identifier of the task to cancel. + /// + [JsonPropertyName("taskId")] + public required string TaskId { get; set; } +} diff --git a/src/ModelContextProtocol.Extensions.Tasks/Protocol/CancelTaskResult.cs b/src/ModelContextProtocol.Extensions.Tasks/Protocol/CancelTaskResult.cs new file mode 100644 index 000000000..5176cfa56 --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Tasks/Protocol/CancelTaskResult.cs @@ -0,0 +1,28 @@ +using ModelContextProtocol.Protocol; +using System.Text.Json.Serialization; + +namespace ModelContextProtocol.Extensions.Tasks; + +/// +/// Represents the result of a tasks/cancel request. This is an empty acknowledgement. +/// +/// +/// +/// The server acknowledges the request with an empty result. Cancellation processing is +/// eventually consistent — the task's observable status may remain +/// after the ack, and may ultimately reach a terminal status other than +/// if the work finished before cancellation could take effect. +/// +/// +/// See the SEP-2663 +/// specification for details. +/// +/// +public sealed class CancelTaskResult : Result +{ + /// Initializes a new task cancellation acknowledgement. + public CancelTaskResult() + { + ResultType = "complete"; + } +} diff --git a/src/ModelContextProtocol.Extensions.Tasks/Protocol/CreateTaskResult.cs b/src/ModelContextProtocol.Extensions.Tasks/Protocol/CreateTaskResult.cs new file mode 100644 index 000000000..7cbb5d134 --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Tasks/Protocol/CreateTaskResult.cs @@ -0,0 +1,78 @@ +using ModelContextProtocol.Protocol; +using System.Text.Json; +using System.Text.Json.Nodes; +using System.Text.Json.Serialization; + +namespace ModelContextProtocol.Extensions.Tasks; + +/// +/// Represents the result returned by a server when it creates a task in lieu of a standard result. +/// +/// +/// +/// A server returns instead of the standard result shape (e.g., ) +/// to indicate that the request will be processed asynchronously. The client then uses +/// for subsequent tasks/get, tasks/update, and tasks/cancel calls. +/// +/// +/// A server must not return to a client that did not include the +/// io.modelcontextprotocol/tasks extension capability on its request. +/// +/// +/// See the SEP-2663 +/// specification for details. +/// +/// +public sealed class CreateTaskResult : Result +{ + /// + /// Initializes a new instance of the class. + /// + public CreateTaskResult() + { + ResultType = "task"; + } + + /// + /// Gets or sets the stable identifier for this task. + /// + [JsonPropertyName("taskId")] + public required string TaskId { get; set; } + + /// + /// Gets or sets the current task status. + /// + [JsonPropertyName("status")] + public required McpTaskStatus Status { get; set; } + + /// + /// Gets or sets an optional message describing the current task state. + /// + [JsonPropertyName("statusMessage")] + public string? StatusMessage { get; set; } + + /// + /// Gets or sets the ISO 8601 timestamp when the task was created. + /// + [JsonPropertyName("createdAt")] + public required DateTimeOffset CreatedAt { get; set; } + + /// + /// Gets or sets the ISO 8601 timestamp when the task was last updated. + /// + [JsonPropertyName("lastUpdatedAt")] + public required DateTimeOffset LastUpdatedAt { get; set; } + + /// + /// Gets or sets the time-to-live duration from creation, or for unlimited. + /// + [JsonPropertyName("ttlMs")] + [JsonConverter(typeof(TimeSpanMillisecondsConverter))] + public TimeSpan? TimeToLive { get; set; } + + /// + /// Gets or sets the suggested polling interval in milliseconds. + /// + [JsonPropertyName("pollIntervalMs")] + public long? PollIntervalMs { get; set; } +} diff --git a/src/ModelContextProtocol.Extensions.Tasks/Protocol/GetTaskRequestParams.cs b/src/ModelContextProtocol.Extensions.Tasks/Protocol/GetTaskRequestParams.cs new file mode 100644 index 000000000..a865bf690 --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Tasks/Protocol/GetTaskRequestParams.cs @@ -0,0 +1,27 @@ +using ModelContextProtocol.Protocol; +using System.Text.Json.Serialization; + +namespace ModelContextProtocol.Extensions.Tasks; + +/// +/// Represents the parameters for a tasks/get request to poll for task completion. +/// +/// +/// +/// Clients poll for task completion by sending tasks/get requests. +/// Clients should respect the provided in responses +/// when determining polling frequency. +/// +/// +/// See the SEP-2663 +/// specification for details. +/// +/// +public sealed class GetTaskRequestParams : RequestParams +{ + /// + /// Gets or sets the identifier of the task to query. + /// + [JsonPropertyName("taskId")] + public required string TaskId { get; set; } +} diff --git a/src/ModelContextProtocol.Extensions.Tasks/Protocol/GetTaskResult.cs b/src/ModelContextProtocol.Extensions.Tasks/Protocol/GetTaskResult.cs new file mode 100644 index 000000000..4d083d8a1 --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Tasks/Protocol/GetTaskResult.cs @@ -0,0 +1,450 @@ +using ModelContextProtocol.Protocol; +using System.Text.Json; +using System.Text.Json.Nodes; +using System.Text.Json.Serialization; + +namespace ModelContextProtocol.Extensions.Tasks; + +/// +/// Represents the result of a tasks/get request, containing the full task state. +/// +/// +/// +/// This is the abstract base for status-specific task results. The concrete type returned depends on the +/// task's current : +/// +/// — +/// — +/// — +/// — +/// — +/// +/// +/// +/// See the SEP-2663 +/// specification for details. +/// +/// +[JsonConverter(typeof(Converter))] +public abstract class GetTaskResult : Result +{ + /// Prevent external derivations. + private protected GetTaskResult() + { + } + + /// + /// Gets or sets the stable identifier for this task. + /// + [JsonPropertyName("taskId")] + public required string TaskId { get; set; } + + /// + /// Gets or sets the current task status. + /// + [JsonPropertyName("status")] + public abstract McpTaskStatus Status { get; } + + /// + /// Gets or sets an optional message describing the current task state. + /// + [JsonPropertyName("statusMessage")] + public string? StatusMessage { get; set; } + + /// + /// Gets or sets the ISO 8601 timestamp when the task was created. + /// + [JsonPropertyName("createdAt")] + public required DateTimeOffset CreatedAt { get; set; } + + /// + /// Gets or sets the ISO 8601 timestamp when the task was last updated. + /// + [JsonPropertyName("lastUpdatedAt")] + public required DateTimeOffset LastUpdatedAt { get; set; } + + /// + /// Gets or sets the time-to-live duration from creation, or for unlimited. + /// + [JsonPropertyName("ttlMs")] + public TimeSpan? TimeToLive { get; set; } + + /// + /// Gets or sets the suggested polling interval in milliseconds. + /// + [JsonPropertyName("pollIntervalMs")] + public long? PollIntervalMs { get; set; } + + /// + /// JSON converter that deserializes to the appropriate concrete subtype + /// based on the status discriminator field. + /// + internal sealed class Converter : JsonConverter + { + public override GetTaskResult? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + if (reader.TokenType != JsonTokenType.StartObject) + { + throw new JsonException("Expected StartObject token for GetTaskResult."); + } + + string? taskId = null; + string? statusString = null; + string? statusMessage = null; + DateTimeOffset? createdAt = null; + DateTimeOffset? lastUpdatedAt = null; + long? ttlMs = null; + long? pollIntervalMs = null; + string? resultType = null; + JsonObject? meta = null; + JsonElement? result = null; + JsonElement? error = null; + Dictionary? inputRequests = null; + + while (reader.Read()) + { + if (reader.TokenType == JsonTokenType.EndObject) + { + break; + } + + if (reader.TokenType != JsonTokenType.PropertyName) + { + throw new JsonException("Expected property name."); + } + + string propertyName = reader.GetString()!; + reader.Read(); + + switch (propertyName) + { + case "taskId": + taskId = reader.GetString(); + break; + case "status": + statusString = reader.GetString(); + break; + case "statusMessage": + statusMessage = reader.GetString(); + break; + case "createdAt": + createdAt = reader.GetDateTimeOffset(); + break; + case "lastUpdatedAt": + lastUpdatedAt = reader.GetDateTimeOffset(); + break; + case "ttlMs": + ttlMs = reader.GetInt64(); + break; + case "pollIntervalMs": + pollIntervalMs = reader.GetInt64(); + break; + case "resultType": + resultType = reader.GetString(); + break; + case "_meta": + meta = JsonSerializer.Deserialize(ref reader, options.GetTypeInfo()); + break; + case "result": + result = JsonElement.ParseValue(ref reader); + break; + case "error": + error = JsonElement.ParseValue(ref reader); + break; + case "inputRequests": + if (reader.TokenType != JsonTokenType.StartObject) + { + throw new JsonException("'inputRequests' must be a JSON object."); + } + inputRequests = new Dictionary(StringComparer.Ordinal); + while (reader.Read()) + { + if (reader.TokenType == JsonTokenType.EndObject) + { + break; + } + if (reader.TokenType != JsonTokenType.PropertyName) + { + throw new JsonException("Expected property name in 'inputRequests'."); + } + string requestKey = reader.GetString()!; + reader.Read(); + var inputRequest = JsonSerializer.Deserialize(ref reader, McpJsonUtilities.DefaultOptions.GetTypeInfo()) + ?? throw new JsonException($"Failed to deserialize InputRequest for key '{requestKey}'."); + inputRequests[requestKey] = inputRequest; + } + break; + default: + reader.Skip(); + break; + } + } + + if (taskId is null) + { + throw new JsonException("Missing required 'taskId' property on GetTaskResult."); + } + + if (statusString is null) + { + throw new JsonException("Missing required 'status' property on GetTaskResult."); + } + + if (createdAt is null) + { + throw new JsonException("Missing required 'createdAt' property on GetTaskResult."); + } + + if (lastUpdatedAt is null) + { + throw new JsonException("Missing required 'lastUpdatedAt' property on GetTaskResult."); + } + + GetTaskResult taskResult = statusString switch + { + "working" => new WorkingTaskResult + { + TaskId = taskId, + CreatedAt = createdAt.Value, + LastUpdatedAt = lastUpdatedAt.Value, + }, + "completed" => result is not null + ? new CompletedTaskResult + { + TaskId = taskId, + CreatedAt = createdAt.Value, + LastUpdatedAt = lastUpdatedAt.Value, + Result = result.Value, + } + : throw new JsonException("Completed task is missing required 'result' property."), + "failed" => error is not null + ? new FailedTaskResult + { + TaskId = taskId, + CreatedAt = createdAt.Value, + LastUpdatedAt = lastUpdatedAt.Value, + Error = error.Value, + } + : throw new JsonException("Failed task is missing required 'error' property."), + "cancelled" => new CancelledTaskResult + { + TaskId = taskId, + CreatedAt = createdAt.Value, + LastUpdatedAt = lastUpdatedAt.Value, + }, + "input_required" => inputRequests is not null + ? new InputRequiredTaskResult + { + TaskId = taskId, + CreatedAt = createdAt.Value, + LastUpdatedAt = lastUpdatedAt.Value, + InputRequests = inputRequests, + } + : throw new JsonException("Input-required task is missing required 'inputRequests' property."), + _ => throw new JsonException($"Unknown task status: '{statusString}'.") + }; + + taskResult.StatusMessage = statusMessage; + taskResult.TimeToLive = ttlMs is null ? null : TimeSpan.FromMilliseconds(ttlMs.Value); + taskResult.PollIntervalMs = pollIntervalMs; + taskResult.ResultType = resultType; + taskResult.Meta = meta; + + return taskResult; + } + + public override void Write(Utf8JsonWriter writer, GetTaskResult value, JsonSerializerOptions options) + { + writer.WriteStartObject(); + + if (value.ResultType is not null) + { + writer.WriteString("resultType", value.ResultType); + } + + if (value.Meta is not null) + { + writer.WritePropertyName("_meta"); + JsonSerializer.Serialize(writer, value.Meta, options.GetTypeInfo()); + } + + writer.WriteString("taskId", value.TaskId); + writer.WriteString("status", value.Status switch + { + McpTaskStatus.Working => "working", + McpTaskStatus.Completed => "completed", + McpTaskStatus.Failed => "failed", + McpTaskStatus.Cancelled => "cancelled", + McpTaskStatus.InputRequired => "input_required", + _ => throw new JsonException($"Unknown McpTaskStatus: {value.Status}") + }); + + if (value.StatusMessage is not null) + { + writer.WriteString("statusMessage", value.StatusMessage); + } + + writer.WriteString("createdAt", value.CreatedAt); + writer.WriteString("lastUpdatedAt", value.LastUpdatedAt); + + if (value.TimeToLive is not null) + { + writer.WriteNumber("ttlMs", (long)value.TimeToLive.Value.TotalMilliseconds); + } + + if (value.PollIntervalMs is not null) + { + writer.WriteNumber("pollIntervalMs", value.PollIntervalMs.Value); + } + + switch (value) + { + case CompletedTaskResult completed: + writer.WritePropertyName("result"); + completed.Result.WriteTo(writer); + break; + case FailedTaskResult failed: + writer.WritePropertyName("error"); + failed.Error.WriteTo(writer); + break; + case InputRequiredTaskResult inputRequired: + writer.WritePropertyName("inputRequests"); + writer.WriteStartObject(); + if (inputRequired.InputRequests is { } reqs) + { + foreach (var kvp in reqs) + { + writer.WritePropertyName(kvp.Key); + JsonSerializer.Serialize(writer, kvp.Value, McpJsonUtilities.DefaultOptions.GetTypeInfo()); + } + } + writer.WriteEndObject(); + break; + } + + writer.WriteEndObject(); + } + } +} + +/// +/// Represents a task that is currently being processed by the server. +/// +/// +/// See the SEP-2663 +/// specification for details. +/// +public sealed class WorkingTaskResult : GetTaskResult +{ + /// + [JsonPropertyName("status")] + public override McpTaskStatus Status => McpTaskStatus.Working; +} + +/// +/// Represents a task that has completed successfully, carrying the final result. +/// +/// +/// +/// The field contains the result structure matching the original request type. +/// For example, a tools/call task would contain the structure. +/// This includes tool calls that returned results with isError: true. +/// +/// +/// See the SEP-2663 +/// specification for details. +/// +/// +public sealed class CompletedTaskResult : GetTaskResult +{ + /// + [JsonPropertyName("status")] + public override McpTaskStatus Status => McpTaskStatus.Completed; + + /// + /// Gets or sets the final result of the task as raw JSON. + /// + /// + /// The structure matches the result type of the original request. + /// + [JsonPropertyName("result")] + public required JsonElement Result { get; set; } +} + +/// +/// Represents a task that failed due to a JSON-RPC error during execution. +/// +/// +/// +/// The field contains the JSON-RPC error object that caused the failure. +/// This status must not be used for non-JSON-RPC errors. +/// +/// +/// See the SEP-2663 +/// specification for details. +/// +/// +public sealed class FailedTaskResult : GetTaskResult +{ + /// + [JsonPropertyName("status")] + public override McpTaskStatus Status => McpTaskStatus.Failed; + + /// + /// Gets or sets the JSON-RPC error that caused the task to fail. + /// + [JsonPropertyName("error")] + public required JsonElement Error { get; set; } +} + +/// +/// Represents a task that was cancelled before completion. +/// +/// +/// See the SEP-2663 +/// specification for details. +/// +public sealed class CancelledTaskResult : GetTaskResult +{ + /// + [JsonPropertyName("status")] + public override McpTaskStatus Status => McpTaskStatus.Cancelled; +} + +/// +/// Represents a task that requires input from the client before it can proceed. +/// +/// +/// +/// The field contains outstanding server-to-client requests +/// that the client must fulfil. Each entry is keyed by an arbitrary identifier for matching +/// requests to responses, and each value is an wrapping the +/// server-to-client request payload. +/// +/// +/// Clients must treat each entry as they would the equivalent standalone server-to-client request. +/// Clients should deduplicate keys across consecutive polls to avoid presenting the same request +/// to the user or model more than once. +/// +/// +/// See the SEP-2663 +/// specification for details. +/// +/// +public sealed class InputRequiredTaskResult : GetTaskResult +{ + /// + [JsonPropertyName("status")] + public override McpTaskStatus Status => McpTaskStatus.InputRequired; + + /// + /// Gets or sets the server-to-client requests that need to be fulfilled. + /// + /// + /// Keys are arbitrary identifiers for matching requests to responses. + /// Each value is an wrapping the server-to-client request + /// (e.g., a sampling, elicitation, or roots-list request). + /// + [JsonPropertyName("inputRequests")] + public IDictionary? InputRequests { get; set; } +} diff --git a/src/ModelContextProtocol.Extensions.Tasks/Protocol/McpTaskStatus.cs b/src/ModelContextProtocol.Extensions.Tasks/Protocol/McpTaskStatus.cs new file mode 100644 index 000000000..90ee12d27 --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Tasks/Protocol/McpTaskStatus.cs @@ -0,0 +1,50 @@ +using ModelContextProtocol.Protocol; +using System.Text.Json.Serialization; + +namespace ModelContextProtocol.Extensions.Tasks; + +/// +/// Represents the status of an MCP task. +/// +/// +/// Tasks are durable state machines that carry information about the underlying execution state +/// of the request they augment. See the +/// SEP-2663 +/// specification for details. +/// +[JsonConverter(typeof(JsonStringEnumConverter))] +public enum McpTaskStatus +{ + /// + /// The request is currently being processed. + /// + [JsonStringEnumMemberName("working")] + Working, + + /// + /// The server needs input from the client before the task can proceed. + /// The tasks/get response will include outstanding requests in the inputRequests field. + /// + [JsonStringEnumMemberName("input_required")] + InputRequired, + + /// + /// The request completed successfully and results are available. + /// This includes tool calls that returned results with isError: true. + /// + [JsonStringEnumMemberName("completed")] + Completed, + + /// + /// The request was cancelled before completion. + /// + [JsonStringEnumMemberName("cancelled")] + Cancelled, + + /// + /// The request failed due to a JSON-RPC error during execution. + /// This status must not be used for non-JSON-RPC errors. + /// + [JsonStringEnumMemberName("failed")] + Failed, +} diff --git a/src/ModelContextProtocol.Extensions.Tasks/Protocol/ResultOrCreatedTask.cs b/src/ModelContextProtocol.Extensions.Tasks/Protocol/ResultOrCreatedTask.cs new file mode 100644 index 000000000..1e9100c67 --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Tasks/Protocol/ResultOrCreatedTask.cs @@ -0,0 +1,83 @@ +using ModelContextProtocol.Protocol; +namespace ModelContextProtocol.Extensions.Tasks; + +/// +/// Represents the result of a request that supports task-augmented execution, which may be either +/// the standard result or a indicating asynchronous processing. +/// +/// The standard result type for the request (e.g., ). +/// +/// +/// When a server supports the io.modelcontextprotocol/tasks extension and the client declares +/// the extension capability on its request, the server may return a +/// instead of the standard result. This type represents that polymorphic response. +/// +/// +/// Use to determine which variant was returned, then access either +/// for the immediate result or for the task handle. +/// +/// +/// See the SEP-2663 +/// specification for details. +/// +/// +public class ResultOrCreatedTask where TResult : Result +{ + private readonly TResult? _result; + private readonly CreateTaskResult? _taskCreated; + + /// + /// Initializes a new instance of with an immediate result. + /// + /// The standard result returned by the server. + public ResultOrCreatedTask(TResult result) + { + if (result is null) + { + throw new ArgumentNullException(nameof(result)); + } + _result = result; + } + + /// + /// Initializes a new instance of with a task handle. + /// + /// The task creation result returned by the server. + public ResultOrCreatedTask(CreateTaskResult taskCreated) + { + if (taskCreated is null) + { + throw new ArgumentNullException(nameof(taskCreated)); + } + _taskCreated = taskCreated; + } + + /// + /// Gets a value indicating whether the server created a task instead of returning an immediate result. + /// + public bool IsTask => _taskCreated is not null; + + /// + /// Gets the immediate result, or if the server created a task. + /// + public TResult? Result => _result; + + /// + /// Gets the task creation result, or if the server returned an immediate result. + /// + public CreateTaskResult? TaskCreated => _taskCreated; + + /// + /// Implicitly converts a to a + /// wrapping the immediate result. + /// + /// The result to wrap. + public static implicit operator ResultOrCreatedTask(TResult result) => new(result); + + /// + /// Implicitly converts a to a + /// wrapping the task handle. + /// + /// The task creation result to wrap. + public static implicit operator ResultOrCreatedTask(CreateTaskResult taskCreated) => new(taskCreated); +} diff --git a/src/ModelContextProtocol.Extensions.Tasks/Protocol/TaskStatusNotificationParams.cs b/src/ModelContextProtocol.Extensions.Tasks/Protocol/TaskStatusNotificationParams.cs new file mode 100644 index 000000000..020896a1f --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Tasks/Protocol/TaskStatusNotificationParams.cs @@ -0,0 +1,392 @@ +using ModelContextProtocol.Protocol; +using System.Text.Json; +using System.Text.Json.Nodes; +using System.Text.Json.Serialization; + +namespace ModelContextProtocol.Extensions.Tasks; + +/// +/// Represents the parameters for a notifications/tasks notification sent by the server +/// to push task status updates to the client. +/// +/// +/// +/// Each notification carries a complete task state for the current status, identical to what +/// tasks/get would have returned at that moment. The concrete type depends on the task's +/// current status: +/// +/// — +/// — +/// — +/// — +/// — +/// +/// +/// +/// To receive task status notifications, clients send a subscriptions/listen request +/// including the task IDs they are interested in. +/// +/// +/// See the SEP-2663 +/// specification for details. +/// +/// +[JsonConverter(typeof(Converter))] +public abstract class TaskStatusNotificationParams : NotificationParams +{ + /// Prevent external derivations. + private protected TaskStatusNotificationParams() + { + } + + /// + /// Gets or sets the stable identifier for this task. + /// + [JsonPropertyName("taskId")] + public required string TaskId { get; set; } + + /// + /// Gets or sets the current task status. + /// + [JsonPropertyName("status")] + public abstract McpTaskStatus Status { get; } + + /// + /// Gets or sets an optional message describing the current task state. + /// + [JsonPropertyName("statusMessage")] + public string? StatusMessage { get; set; } + + /// + /// Gets or sets the ISO 8601 timestamp when the task was created. + /// + [JsonPropertyName("createdAt")] + public required DateTimeOffset CreatedAt { get; set; } + + /// + /// Gets or sets the ISO 8601 timestamp when the task was last updated. + /// + [JsonPropertyName("lastUpdatedAt")] + public required DateTimeOffset LastUpdatedAt { get; set; } + + /// + /// Gets or sets the time-to-live duration from creation, or for unlimited. + /// + [JsonPropertyName("ttlMs")] + public TimeSpan? TimeToLive { get; set; } + + /// + /// Gets or sets the suggested polling interval in milliseconds. + /// + [JsonPropertyName("pollIntervalMs")] + public long? PollIntervalMs { get; set; } + + /// + /// JSON converter that deserializes to the appropriate + /// concrete subtype based on the status discriminator field. + /// + internal sealed class Converter : JsonConverter + { + public override TaskStatusNotificationParams? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + if (reader.TokenType != JsonTokenType.StartObject) + { + throw new JsonException("Expected StartObject token for TaskStatusNotificationParams."); + } + + string? taskId = null; + string? statusString = null; + string? statusMessage = null; + DateTimeOffset? createdAt = null; + DateTimeOffset? lastUpdatedAt = null; + long? ttlMs = null; + long? pollIntervalMs = null; + JsonObject? meta = null; + JsonElement? result = null; + JsonElement? error = null; + Dictionary? inputRequests = null; + + while (reader.Read()) + { + if (reader.TokenType == JsonTokenType.EndObject) + { + break; + } + + if (reader.TokenType != JsonTokenType.PropertyName) + { + throw new JsonException("Expected property name."); + } + + string propertyName = reader.GetString()!; + reader.Read(); + + switch (propertyName) + { + case "taskId": + taskId = reader.GetString(); + break; + case "status": + statusString = reader.GetString(); + break; + case "statusMessage": + statusMessage = reader.GetString(); + break; + case "createdAt": + createdAt = reader.GetDateTimeOffset(); + break; + case "lastUpdatedAt": + lastUpdatedAt = reader.GetDateTimeOffset(); + break; + case "ttlMs": + ttlMs = reader.GetInt64(); + break; + case "pollIntervalMs": + pollIntervalMs = reader.GetInt64(); + break; + case "_meta": + meta = JsonSerializer.Deserialize(ref reader, options.GetTypeInfo()); + break; + case "result": + result = JsonElement.ParseValue(ref reader); + break; + case "error": + error = JsonElement.ParseValue(ref reader); + break; + case "inputRequests": + if (reader.TokenType != JsonTokenType.StartObject) + { + throw new JsonException("'inputRequests' must be a JSON object."); + } + inputRequests = new Dictionary(StringComparer.Ordinal); + while (reader.Read()) + { + if (reader.TokenType == JsonTokenType.EndObject) + { + break; + } + if (reader.TokenType != JsonTokenType.PropertyName) + { + throw new JsonException("Expected property name in 'inputRequests'."); + } + string requestKey = reader.GetString()!; + reader.Read(); + var inputRequest = JsonSerializer.Deserialize(ref reader, McpJsonUtilities.DefaultOptions.GetTypeInfo()) + ?? throw new JsonException($"Failed to deserialize InputRequest for key '{requestKey}'."); + inputRequests[requestKey] = inputRequest; + } + break; + default: + reader.Skip(); + break; + } + } + + if (taskId is null) + { + throw new JsonException("Missing required 'taskId' property on TaskStatusNotificationParams."); + } + + if (statusString is null) + { + throw new JsonException("Missing required 'status' property on TaskStatusNotificationParams."); + } + + if (createdAt is null) + { + throw new JsonException("Missing required 'createdAt' property on TaskStatusNotificationParams."); + } + + if (lastUpdatedAt is null) + { + throw new JsonException("Missing required 'lastUpdatedAt' property on TaskStatusNotificationParams."); + } + + TaskStatusNotificationParams notification = statusString switch + { + "working" => new WorkingTaskNotificationParams + { + TaskId = taskId, + CreatedAt = createdAt.Value, + LastUpdatedAt = lastUpdatedAt.Value, + }, + "completed" => result is not null + ? new CompletedTaskNotificationParams + { + TaskId = taskId, + CreatedAt = createdAt.Value, + LastUpdatedAt = lastUpdatedAt.Value, + Result = result.Value, + } + : throw new JsonException("Completed task notification is missing required 'result' property."), + "failed" => error is not null + ? new FailedTaskNotificationParams + { + TaskId = taskId, + CreatedAt = createdAt.Value, + LastUpdatedAt = lastUpdatedAt.Value, + Error = error.Value, + } + : throw new JsonException("Failed task notification is missing required 'error' property."), + "cancelled" => new CancelledTaskNotificationParams + { + TaskId = taskId, + CreatedAt = createdAt.Value, + LastUpdatedAt = lastUpdatedAt.Value, + }, + "input_required" => inputRequests is not null + ? new InputRequiredTaskNotificationParams + { + TaskId = taskId, + CreatedAt = createdAt.Value, + LastUpdatedAt = lastUpdatedAt.Value, + InputRequests = inputRequests, + } + : throw new JsonException("Input-required task notification is missing required 'inputRequests' property."), + _ => throw new JsonException($"Unknown task status: '{statusString}'.") + }; + + notification.StatusMessage = statusMessage; + notification.TimeToLive = ttlMs is null ? null : TimeSpan.FromMilliseconds(ttlMs.Value); + notification.PollIntervalMs = pollIntervalMs; + notification.Meta = meta; + + return notification; + } + + public override void Write(Utf8JsonWriter writer, TaskStatusNotificationParams value, JsonSerializerOptions options) + { + writer.WriteStartObject(); + + if (value.Meta is not null) + { + writer.WritePropertyName("_meta"); + JsonSerializer.Serialize(writer, value.Meta, options.GetTypeInfo()); + } + + writer.WriteString("taskId", value.TaskId); + writer.WriteString("status", value.Status switch + { + McpTaskStatus.Working => "working", + McpTaskStatus.Completed => "completed", + McpTaskStatus.Failed => "failed", + McpTaskStatus.Cancelled => "cancelled", + McpTaskStatus.InputRequired => "input_required", + _ => throw new JsonException($"Unknown McpTaskStatus: {value.Status}") + }); + + if (value.StatusMessage is not null) + { + writer.WriteString("statusMessage", value.StatusMessage); + } + + writer.WriteString("createdAt", value.CreatedAt); + writer.WriteString("lastUpdatedAt", value.LastUpdatedAt); + + if (value.TimeToLive is not null) + { + writer.WriteNumber("ttlMs", (long)value.TimeToLive.Value.TotalMilliseconds); + } + + if (value.PollIntervalMs is not null) + { + writer.WriteNumber("pollIntervalMs", value.PollIntervalMs.Value); + } + + switch (value) + { + case CompletedTaskNotificationParams completed: + writer.WritePropertyName("result"); + completed.Result.WriteTo(writer); + break; + case FailedTaskNotificationParams failed: + writer.WritePropertyName("error"); + failed.Error.WriteTo(writer); + break; + case InputRequiredTaskNotificationParams inputRequired: + writer.WritePropertyName("inputRequests"); + writer.WriteStartObject(); + if (inputRequired.InputRequests is { } reqs) + { + foreach (var kvp in reqs) + { + writer.WritePropertyName(kvp.Key); + JsonSerializer.Serialize(writer, kvp.Value, McpJsonUtilities.DefaultOptions.GetTypeInfo()); + } + } + writer.WriteEndObject(); + break; + } + + writer.WriteEndObject(); + } + } +} + +/// +/// Task notification for a task that is currently being processed. +/// +public sealed class WorkingTaskNotificationParams : TaskStatusNotificationParams +{ + /// + public override McpTaskStatus Status => McpTaskStatus.Working; +} + +/// +/// Task notification for a task that has completed successfully. +/// +public sealed class CompletedTaskNotificationParams : TaskStatusNotificationParams +{ + /// + public override McpTaskStatus Status => McpTaskStatus.Completed; + + /// + /// Gets or sets the final result of the task. + /// + [JsonPropertyName("result")] + public required JsonElement Result { get; set; } +} + +/// +/// Task notification for a task that failed. +/// +public sealed class FailedTaskNotificationParams : TaskStatusNotificationParams +{ + /// + public override McpTaskStatus Status => McpTaskStatus.Failed; + + /// + /// Gets or sets the JSON-RPC error that caused the task to fail. + /// + [JsonPropertyName("error")] + public required JsonElement Error { get; set; } +} + +/// +/// Task notification for a task that was cancelled. +/// +public sealed class CancelledTaskNotificationParams : TaskStatusNotificationParams +{ + /// + public override McpTaskStatus Status => McpTaskStatus.Cancelled; +} + +/// +/// Task notification for a task that requires input from the client. +/// +public sealed class InputRequiredTaskNotificationParams : TaskStatusNotificationParams +{ + /// + public override McpTaskStatus Status => McpTaskStatus.InputRequired; + + /// + /// Gets or sets the server-to-client requests that need to be fulfilled. + /// + /// + /// Keys are arbitrary identifiers for matching requests to responses. Each value is an + /// wrapping the server-to-client request payload, matching + /// the typed format defined by the Multi Round-Trip Requests (MRTR) extension (SEP-2322). + /// + [JsonPropertyName("inputRequests")] + public IDictionary? InputRequests { get; set; } +} diff --git a/src/ModelContextProtocol.Extensions.Tasks/Protocol/UpdateTaskRequestParams.cs b/src/ModelContextProtocol.Extensions.Tasks/Protocol/UpdateTaskRequestParams.cs new file mode 100644 index 000000000..aeeb2c79a --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Tasks/Protocol/UpdateTaskRequestParams.cs @@ -0,0 +1,30 @@ +using ModelContextProtocol.Protocol; +using System.Text.Json.Serialization; + +namespace ModelContextProtocol.Extensions.Tasks; + +/// +/// Represents the parameters for a tasks/update request to provide input responses +/// to outstanding server-to-client requests on a task. +/// +/// +/// +/// When a task requires input from the client (indicated by ), +/// the server includes outstanding requests in the inputRequests field of the tasks/get response. +/// The client provides responses via the inherited field in +/// tasks/update requests; the wire format matches the typed envelope defined by the Multi Round-Trip +/// Requests (MRTR) extension (SEP-2322). +/// +/// +/// See the SEP-2663 +/// specification for details. +/// +/// +public sealed class UpdateTaskRequestParams : RequestParams +{ + /// + /// Gets or sets the identifier of the task to update. + /// + [JsonPropertyName("taskId")] + public required string TaskId { get; set; } +} diff --git a/src/ModelContextProtocol.Extensions.Tasks/Protocol/UpdateTaskResult.cs b/src/ModelContextProtocol.Extensions.Tasks/Protocol/UpdateTaskResult.cs new file mode 100644 index 000000000..0a7488688 --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Tasks/Protocol/UpdateTaskResult.cs @@ -0,0 +1,27 @@ +using ModelContextProtocol.Protocol; +using System.Text.Json.Serialization; + +namespace ModelContextProtocol.Extensions.Tasks; + +/// +/// Represents the result of a tasks/update request. This is an empty acknowledgement. +/// +/// +/// +/// On success, the server acknowledges the request with an empty result. +/// The acknowledgement is eventually consistent: the server may accept the responses and +/// return the ack before the task's observable status reflects them. +/// +/// +/// See the SEP-2663 +/// specification for details. +/// +/// +public sealed class UpdateTaskResult : Result +{ + /// Initializes a new task update acknowledgement. + public UpdateTaskResult() + { + ResultType = "complete"; + } +} diff --git a/src/ModelContextProtocol.Extensions.Tasks/Server/IMcpTaskStore.cs b/src/ModelContextProtocol.Extensions.Tasks/Server/IMcpTaskStore.cs new file mode 100644 index 000000000..6851f21ac --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Tasks/Server/IMcpTaskStore.cs @@ -0,0 +1,154 @@ +using ModelContextProtocol.Protocol; +using System.Text.Json; + +namespace ModelContextProtocol.Extensions.Tasks; + +/// +/// Provides an interface for storing and managing the lifecycle of MCP tasks. +/// +/// +/// +/// The task store manages the state of tasks created by the server's request handling pipeline. +/// When a client signals support for the io.modelcontextprotocol/tasks extension on a request, +/// the server creates a task in the store, executes the work in the background, and stores the result +/// upon completion. +/// +/// +/// Implementations must be thread-safe. The store also provides the backing implementation for +/// tasks/get, tasks/update, and tasks/cancel protocol methods. +/// +/// +/// Lifetime under stateless HTTP: when the server is configured for stateless HTTP +/// (each request creates a fresh server instance), the same instance +/// MUST be shared across requests — either by registering the store as a singleton in the DI +/// container, or by backing it with external storage (database, distributed cache, etc.) that +/// every server instance can reach. Otherwise tasks/get polls issued on subsequent +/// requests will see an empty in-memory store and never find the task they are polling for. +/// +/// +/// See the SEP-2663 +/// specification for details on the tasks extension. +/// +/// +public interface IMcpTaskStore +{ + /// + /// Creates a new task for tracking an asynchronous execution. + /// + /// Cancellation token for the operation. + /// + /// A with a unique task ID, initial status of , + /// and timing metadata (TTL, poll interval). + /// + /// + /// + /// Implementations must generate a unique task ID and set appropriate timestamps. + /// The server infrastructure maps the returned to the appropriate + /// protocol response type when communicating with clients. + /// + /// + /// Per the MCP specification (SEP-2663 §306), the returned task MUST be durably created + /// before this method completes: a subsequent with the returned + /// MUST resolve, even if it runs on a different process or + /// node. Implementations backed by eventually-consistent storage must therefore wait for the + /// write to be visible (e.g., quorum acknowledgement, write-through, or an equivalent + /// barrier) before returning. + /// + /// + Task CreateTaskAsync(CancellationToken cancellationToken = default); + + /// + /// Retrieves the current state of a task. + /// + /// The unique identifier of the task to retrieve. + /// Cancellation token for the operation. + /// + /// A representing the current task state, + /// or if the task does not exist. + /// + Task GetTaskAsync(string taskId, CancellationToken cancellationToken = default); + + /// + /// Stores the result of a completed execution, transitioning the task to . + /// + /// The unique identifier of the task. + /// The serialized result payload. + /// Cancellation token for the operation. + /// A task representing the asynchronous operation. + Task SetCompletedAsync(string taskId, JsonElement result, CancellationToken cancellationToken = default); + + /// + /// Marks a task as failed, transitioning it to . + /// + /// The unique identifier of the task. + /// The serialized error information. + /// Cancellation token for the operation. + /// A task representing the asynchronous operation. + Task SetFailedAsync(string taskId, JsonElement error, CancellationToken cancellationToken = default); + + /// + /// Transitions the task to . + /// + /// The unique identifier of the task to cancel. + /// Cancellation token for the operation. + /// + /// if the task was successfully cancelled; + /// if the task does not exist or was already in a terminal state. + /// + Task SetCancelledAsync(string taskId, CancellationToken cancellationToken = default); + + /// + /// Removes input requests that have been satisfied by the provided responses and + /// raises for each resolved entry. + /// + /// The unique identifier of the task. + /// + /// The input responses keyed by the original request identifier. + /// Matched input requests are removed from the task's pending set. + /// + /// Cancellation token for the operation. + /// + /// + /// After removing the satisfied requests, if no pending input requests remain the task + /// transitions back to . Otherwise it remains in + /// . + /// + /// + /// Implementations must raise for each entry in + /// after updating the store state. In distributed + /// deployments, this event enables the originating server to be notified even if a + /// different server instance processes the tasks/update request. + /// + /// + Task ResolveInputRequestsAsync( + string taskId, + IDictionary inputResponses, + CancellationToken cancellationToken = default); + + /// + /// Occurs when an input response is resolved for a task. + /// + /// + /// Implementations must raise this event for each input response resolved in + /// . Subscribers use this to complete + /// pending input request waiters (e.g., elicitation or sampling calls that are + /// awaiting a client response). + /// + event Action? InputResponseReceived; + + /// + /// Adds input requests to a task, transitioning it to . + /// + /// The unique identifier of the task. + /// + /// The input requests to add. Keys are arbitrary identifiers for matching requests to responses. + /// Each value is an wrapping the server-to-client request payload. + /// New requests are merged with any existing pending requests. + /// + /// Cancellation token for the operation. + /// A task representing the asynchronous operation. + Task SetInputRequestsAsync( + string taskId, + IDictionary inputRequests, + CancellationToken cancellationToken = default); +} diff --git a/src/ModelContextProtocol.Extensions.Tasks/Server/InMemoryMcpTaskStore.cs b/src/ModelContextProtocol.Extensions.Tasks/Server/InMemoryMcpTaskStore.cs new file mode 100644 index 000000000..d1014c110 --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Tasks/Server/InMemoryMcpTaskStore.cs @@ -0,0 +1,274 @@ +using ModelContextProtocol.Protocol; +using System.Collections.Concurrent; +using System.Collections.Immutable; +using System.Text.Json; + +namespace ModelContextProtocol.Extensions.Tasks; + +/// +/// Provides an in-memory implementation of for development and testing scenarios. +/// +/// +/// +/// This implementation stores all task state in memory using immutable snapshots and +/// compare-and-swap updates for thread safety without locks. +/// Tasks are not persisted across process restarts. +/// +/// +/// Tasks created with a are discarded once their time-to-live +/// elapses (as permitted by SEP-2663): an expired task is removed on access, and an opportunistic +/// throttled sweep reclaims expired tasks that are never polled again. Tasks created without a +/// time-to-live are retained until the process exits. +/// +/// +/// For production scenarios requiring durability, session isolation, or more advanced retention +/// policies, implement a custom . +/// +/// +public class InMemoryMcpTaskStore : IMcpTaskStore +{ + private readonly ConcurrentDictionary _tasks = new(); + private static readonly long s_sweepIntervalTicks = TimeSpan.FromSeconds(30).Ticks; + private long _lastSweepTicks = DateTimeOffset.UtcNow.UtcTicks; + + /// + /// Gets or sets the default poll interval in milliseconds for new tasks. + /// + /// The default is 1000 milliseconds. + public long DefaultPollIntervalMs { get; set; } = 1000; + + /// + /// Gets or sets the default time-to-live for new tasks, or for unlimited. + /// + /// + /// When set to a positive value, tasks are discarded once this duration elapses from their + /// creation. A or non-positive value keeps tasks until the process exits. + /// + public TimeSpan? DefaultTimeToLive { get; set; } + + /// + public Task CreateTaskAsync(CancellationToken cancellationToken = default) + { + var now = DateTimeOffset.UtcNow; + SweepExpired(now); + + var taskId = Guid.NewGuid().ToString("N"); + + var info = new McpTaskInfo(taskId, McpTaskStatus.Working, now, now, DefaultTimeToLive, DefaultPollIntervalMs); + _tasks[taskId] = info; + + return Task.FromResult(info); + } + + /// + public Task GetTaskAsync(string taskId, CancellationToken cancellationToken = default) + { + var now = DateTimeOffset.UtcNow; + if (_tasks.TryGetValue(taskId, out var info)) + { + if (IsExpired(info, now)) + { + _tasks.TryRemove(taskId, out _); + return Task.FromResult(null); + } + + return Task.FromResult(info); + } + + return Task.FromResult(null); + } + + /// + public Task SetCompletedAsync(string taskId, JsonElement result, CancellationToken cancellationToken = default) + { + Update(taskId, entry => IsTerminal(entry.Status) + ? entry + : entry with + { + Status = McpTaskStatus.Completed, + Result = result, + LastUpdatedAt = DateTimeOffset.UtcNow, + }); + + return Task.CompletedTask; + } + + /// + public Task SetFailedAsync(string taskId, JsonElement error, CancellationToken cancellationToken = default) + { + Update(taskId, entry => IsTerminal(entry.Status) + ? entry + : entry with + { + Status = McpTaskStatus.Failed, + Error = error, + LastUpdatedAt = DateTimeOffset.UtcNow, + }); + + return Task.CompletedTask; + } + + /// + public Task SetCancelledAsync(string taskId, CancellationToken cancellationToken = default) + { + if (!_tasks.TryGetValue(taskId, out var entry) || IsTerminal(entry.Status)) + { + return Task.FromResult(false); + } + + bool transitioned = false; + Update(taskId, e => + { + if (IsTerminal(e.Status)) + { + return e; + } + + transitioned = true; + return e with { Status = McpTaskStatus.Cancelled, LastUpdatedAt = DateTimeOffset.UtcNow }; + }); + + return Task.FromResult(transitioned); + } + + /// + public event Action? InputResponseReceived; + + /// + public Task ResolveInputRequestsAsync( + string taskId, + IDictionary inputResponses, + CancellationToken cancellationToken = default) + { + bool wasTerminal = false; + Update(taskId, entry => + { + if (IsTerminal(entry.Status)) + { + wasTerminal = true; + return entry; + } + + var requests = entry.InputRequests as ImmutableDictionary + ?? entry.InputRequests?.ToImmutableDictionary() + ?? ImmutableDictionary.Empty; + + foreach (var key in inputResponses.Keys) + { + requests = requests.Remove(key); + } + + var status = requests.IsEmpty ? McpTaskStatus.Working : entry.Status; + + return entry with + { + InputRequests = requests, + Status = status, + LastUpdatedAt = DateTimeOffset.UtcNow, + }; + }); + + if (wasTerminal) + { + // Drop responses targeting a terminal task — there are no listeners that can act on them. + return Task.CompletedTask; + } + + foreach (var kvp in inputResponses) + { + InputResponseReceived?.Invoke(new InputResponseReceivedEventArgs + { + TaskId = taskId, + RequestId = kvp.Key, + Response = kvp.Value, + }); + } + + return Task.CompletedTask; + } + + /// + public Task SetInputRequestsAsync( + string taskId, + IDictionary inputRequests, + CancellationToken cancellationToken = default) + { + Update(taskId, entry => + { + if (IsTerminal(entry.Status)) + { + return entry; + } + + var requests = entry.InputRequests as ImmutableDictionary + ?? entry.InputRequests?.ToImmutableDictionary() + ?? ImmutableDictionary.Empty; + + foreach (var kvp in inputRequests) + { + requests = requests.SetItem(kvp.Key, kvp.Value); + } + + return entry with + { + InputRequests = requests, + Status = McpTaskStatus.InputRequired, + LastUpdatedAt = DateTimeOffset.UtcNow, + }; + }); + + return Task.CompletedTask; + } + + private static bool IsTerminal(McpTaskStatus status) => + status is McpTaskStatus.Completed or McpTaskStatus.Failed or McpTaskStatus.Cancelled; + + private static bool IsExpired(McpTaskInfo info, DateTimeOffset now) => + info.TimeToLive is { } ttl && ttl > TimeSpan.Zero && now - info.CreatedAt >= ttl; + + private void SweepExpired(DateTimeOffset now) + { + long last = Interlocked.Read(ref _lastSweepTicks); + if (now.UtcTicks - last < s_sweepIntervalTicks) + { + return; + } + + // Ensure only one caller runs the sweep per interval; concurrent callers skip it. + if (Interlocked.CompareExchange(ref _lastSweepTicks, now.UtcTicks, last) != last) + { + return; + } + + foreach (var kvp in _tasks) + { + if (IsExpired(kvp.Value, now)) + { + // TaskId values are unique GUIDs that are never reused, and CreatedAt/TimeToLive + // are immutable after creation, so an entry judged expired here stays expired. + // Removing by key is therefore safe even if the value was concurrently updated. + _tasks.TryRemove(kvp.Key, out _); + } + } + } + + private void Update(string taskId, Func transform) + { + SpinWait spin = default; + while (true) + { + if (!_tasks.TryGetValue(taskId, out var current)) + { + throw new InvalidOperationException($"Task '{taskId}' not found."); + } + + var updated = transform(current); + if (ReferenceEquals(updated, current) || _tasks.TryUpdate(taskId, updated, current)) + { + return; + } + + spin.SpinOnce(); + } + } +} diff --git a/src/ModelContextProtocol.Extensions.Tasks/Server/InputResponseReceivedEventArgs.cs b/src/ModelContextProtocol.Extensions.Tasks/Server/InputResponseReceivedEventArgs.cs new file mode 100644 index 000000000..c1cedf6d1 --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Tasks/Server/InputResponseReceivedEventArgs.cs @@ -0,0 +1,24 @@ +using ModelContextProtocol.Protocol; + +namespace ModelContextProtocol.Extensions.Tasks; + +/// +/// Provides data for the event. +/// +public sealed class InputResponseReceivedEventArgs +{ + /// + /// Gets the task identifier. + /// + public required string TaskId { get; init; } + + /// + /// Gets the request identifier that was resolved. + /// + public required string RequestId { get; init; } + + /// + /// Gets the response payload. + /// + public required InputResponse Response { get; init; } +} diff --git a/src/ModelContextProtocol.Extensions.Tasks/Server/McpTaskExecutionMode.cs b/src/ModelContextProtocol.Extensions.Tasks/Server/McpTaskExecutionMode.cs new file mode 100644 index 000000000..9045cea97 --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Tasks/Server/McpTaskExecutionMode.cs @@ -0,0 +1,16 @@ +namespace ModelContextProtocol.Extensions.Tasks; + +/// +/// Specifies how a tool call participates in the MCP Tasks extension. +/// +public enum McpTaskExecutionMode +{ + /// The tool always executes synchronously. + Synchronous, + + /// The tool executes as a task when the client declares the Tasks extension. + Optional, + + /// The tool requires the client to declare the Tasks extension. + Required, +} diff --git a/src/ModelContextProtocol.Extensions.Tasks/Server/McpTaskInfo.cs b/src/ModelContextProtocol.Extensions.Tasks/Server/McpTaskInfo.cs new file mode 100644 index 000000000..a9a86ed54 --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Tasks/Server/McpTaskInfo.cs @@ -0,0 +1,26 @@ +using ModelContextProtocol.Protocol; +using System.Text.Json; + +namespace ModelContextProtocol.Extensions.Tasks; + +/// +/// Represents the state of a task in an . +/// +/// +/// +/// This is the store's representation of a task, decoupled from the MCP protocol wire types. +/// The server infrastructure maps to the appropriate protocol response +/// types (, ) when communicating with clients. +/// +/// +public sealed record McpTaskInfo( + string TaskId, + McpTaskStatus Status, + DateTimeOffset CreatedAt, + DateTimeOffset LastUpdatedAt, + TimeSpan? TimeToLive = null, + long? PollIntervalMs = null, + string? StatusMessage = null, + JsonElement? Result = null, + JsonElement? Error = null, + IReadOnlyDictionary? InputRequests = null); diff --git a/src/ModelContextProtocol.Extensions.Tasks/Server/McpTasksBuilderExtensions.cs b/src/ModelContextProtocol.Extensions.Tasks/Server/McpTasksBuilderExtensions.cs new file mode 100644 index 000000000..e61466a69 --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Tasks/Server/McpTasksBuilderExtensions.cs @@ -0,0 +1,476 @@ +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Logging.Abstractions; +using Microsoft.Extensions.Options; +using ModelContextProtocol; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.Collections.Concurrent; +using System.Text.Json; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.Extensions.Tasks; + +/// +/// Extension methods for to enable MCP Tasks support. +/// +public static class McpTasksBuilderExtensions +{ + /// + /// Enables MCP Tasks support backed by the specified task store. + /// + /// + /// Tasks are implemented as an alternate-result call-tool filter. Alternate-result filters registered before + /// the Tasks filter run before task creation. Filters registered after it, along with all ordinary call-tool + /// filters, run in the background before the tool. + /// + /// The server builder. + /// The task store. + /// The builder provided in . + public static IMcpServerBuilder WithTasks(this IMcpServerBuilder builder, IMcpTaskStore store) + => WithTasks(builder, store, static _ => { }); + + /// + /// Enables MCP Tasks support backed by the specified task store. + /// + /// The server builder. + /// The task store. + /// A callback that configures per-call task execution behavior. + /// The builder provided in . + public static IMcpServerBuilder WithTasks( + this IMcpServerBuilder builder, + IMcpTaskStore store, + Action configure) + { +#if NET + ArgumentNullException.ThrowIfNull(builder); + ArgumentNullException.ThrowIfNull(store); + ArgumentNullException.ThrowIfNull(configure); +#else + if (builder is null) throw new ArgumentNullException(nameof(builder)); + if (store is null) throw new ArgumentNullException(nameof(store)); + if (configure is null) throw new ArgumentNullException(nameof(configure)); +#endif + + McpTasksOptions taskOptions = new(); + configure(taskOptions); +#if NET + ArgumentNullException.ThrowIfNull(taskOptions.ExecutionModeSelector); +#else + if (taskOptions.ExecutionModeSelector is null) throw new ArgumentNullException(nameof(taskOptions.ExecutionModeSelector)); +#endif + + // Resolve ILoggerFactory from the provider (rather than requiring the caller to pass one) so the + // background task body has somewhere to report failures. It is optional: if no logging is + // registered, the options fall back to NullLoggerFactory. + builder.Services.AddSingleton>( + sp => new McpTasksConfigureOptions( + store, + sp.GetRequiredService(), + sp.GetService(), + taskOptions)); + return builder; + } + + private sealed class McpTasksConfigureOptions( + IMcpTaskStore store, + IServiceScopeFactory serviceScopeFactory, + ILoggerFactory? loggerFactory, + McpTasksOptions taskOptions) : IConfigureOptions + { + private readonly IMcpTaskStore _store = store; + private readonly IServiceScopeFactory _serviceScopeFactory = serviceScopeFactory; + private readonly ILogger _logger = (loggerFactory ?? NullLoggerFactory.Instance).CreateLogger(); + private readonly McpTasksOptions _taskOptions = taskOptions; + private readonly ConcurrentDictionary _cancellationSources = new(StringComparer.Ordinal); + + public void Configure(McpServerOptions options) + { +#if NET + ArgumentNullException.ThrowIfNull(options); +#else + if (options is null) throw new ArgumentNullException(nameof(options)); +#endif + + options.Capabilities ??= new ServerCapabilities(); + options.Capabilities.Extensions ??= new Dictionary(); + if (!options.Capabilities.Extensions.ContainsKey(TasksProtocol.ExtensionId)) + { + options.Capabilities.Extensions[TasksProtocol.ExtensionId] = new JsonObject(); + } + + options.RequestHandlers ??= new List(); + options.RequestHandlers.Add(new McpServerRequestHandler + { + Method = TasksProtocol.MethodTasksGet, + RoutingNameParameter = "taskId", + Handler = HandleGetTask, + }); + options.RequestHandlers.Add(new McpServerRequestHandler + { + Method = TasksProtocol.MethodTasksUpdate, + RoutingNameParameter = "taskId", + Handler = HandleUpdateTask, + }); + options.RequestHandlers.Add(new McpServerRequestHandler + { + Method = TasksProtocol.MethodTasksCancel, + RoutingNameParameter = "taskId", + Handler = HandleCancelTask, + }); + + // Use a filter rather than a handler so it wraps around Core's tool dispatch. + // This ensures it intercepts tool calls BEFORE the tool is invoked, allowing + // it to spawn background execution and return the task alternate immediately. + options.Filters.Request.CallToolWithAlternateFilters.Insert( + options.Filters.Request.CallToolWithAlternateFilters.Count, + async (request, next, cancellationToken) => + { + var executionMode = _taskOptions.ExecutionModeSelector(request); + if (executionMode is not McpTaskExecutionMode.Synchronous and + not McpTaskExecutionMode.Optional and + not McpTaskExecutionMode.Required) + { + throw new InvalidOperationException( + $"{nameof(McpTasksOptions.ExecutionModeSelector)} returned an invalid {nameof(McpTaskExecutionMode)} value."); + } + + if (executionMode == McpTaskExecutionMode.Synchronous) + { + return await next(request, cancellationToken).ConfigureAwait(false); + } + + if (!IsJuly2026OrLaterProtocolRequest(request.JsonRpcRequest) || + !HasTaskExtensionOptIn(request.JsonRpcRequest)) + { + if (executionMode == McpTaskExecutionMode.Required) + { + throw CreateMissingTasksCapabilityException(); + } + + return await next(request, cancellationToken).ConfigureAwait(false); + } + + return await RunAsTaskAsync(next, request, cancellationToken).ConfigureAwait(false); + }); + } + + private async ValueTask> RunAsTaskAsync( + McpRequestHandler> next, + RequestContext request, + CancellationToken cancellationToken) + { + var executionScope = _serviceScopeFactory.CreateAsyncScope(); + var executionRequest = new RequestContext( + request.Server, + request.JsonRpcRequest, + request.Params) + { + MatchedPrimitive = request.MatchedPrimitive, + Services = executionScope.ServiceProvider, + }; + + McpTaskInfo taskInfo; + try + { + taskInfo = await _store.CreateTaskAsync(cancellationToken).ConfigureAwait(false); + } + catch + { + await executionScope.DisposeAsync().ConfigureAwait(false); + throw; + } + + var taskId = taskInfo.TaskId; + executionRequest.Server = request.Server.WithMcpTaskOutgoingRequestInterceptor(taskId, _store); + var cts = new CancellationTokenSource(); + _cancellationSources[taskId] = cts; + + // Capture the token before dispatching. Cancellation can remove and dispose the source + // before the background delegate starts. + var taskCancellationToken = cts.Token; + _ = Task.Run( + () => ExecuteTaskAsync(next, executionRequest, taskId, taskCancellationToken, executionScope), + CancellationToken.None); + + return ResultOrAlternate.FromAlternate( + ToCreateTaskResult(taskInfo), + McpTasksJsonContext.Default.CreateTaskResult); + } + + private async Task ExecuteTaskAsync( + McpRequestHandler> next, + RequestContext request, + string taskId, + CancellationToken taskCancellationToken, + AsyncServiceScope executionScope) + { + try + { + try + { + await ExecuteToolPipelineAsync(next, request, taskId, taskCancellationToken).ConfigureAwait(false); + } + finally + { + await executionScope.DisposeAsync().ConfigureAwait(false); + } + } + catch (Exception outer) + { + // Expected outcomes are recorded by ExecuteToolPipelineAsync. Reaching here means a + // store operation, task scope, or service scope failed. Record it best-effort. + _logger.LogError(outer, "Background execution of task '{TaskId}' terminated unexpectedly while recording its result.", taskId); + + try + { + var error = new JsonRpcErrorDetail { Code = (int)McpErrorCode.InternalError, Message = outer.Message }; + var errorJson = JsonSerializer.SerializeToElement(error, McpJsonUtilities.DefaultOptions.GetTypeInfo()); + await _store.SetFailedAsync(taskId, errorJson).ConfigureAwait(false); + } + catch (Exception storeEx) + { + _logger.LogError(storeEx, "Failed to record the failure of background task '{TaskId}'.", taskId); + } + } + finally + { + if (_cancellationSources.TryRemove(taskId, out var registeredCts)) + { + registeredCts.Dispose(); + } + } + } + + private async Task ExecuteToolPipelineAsync( + McpRequestHandler> next, + RequestContext request, + string taskId, + CancellationToken taskCancellationToken) + { + try + { + var augmented = await next(request, taskCancellationToken).ConfigureAwait(false); + + if (augmented.IsAlternate) + { + var error = new JsonRpcErrorDetail + { + Code = (int)McpErrorCode.InternalError, + Message = $"{nameof(IMcpTaskStore)} is configured and the {nameof(McpServerHandlers.CallToolWithAlternateHandler)} returned IsAlternate = true. Use only one mechanism.", + }; + var errorJson = JsonSerializer.SerializeToElement(error, McpJsonUtilities.DefaultOptions.GetTypeInfo()); + await _store.SetFailedAsync(taskId, errorJson).ConfigureAwait(false); + return; + } + + var resultJson = JsonSerializer.SerializeToElement(augmented.Result!, McpJsonUtilities.DefaultOptions.GetTypeInfo()); + await _store.SetCompletedAsync(taskId, resultJson).ConfigureAwait(false); + } + catch (OperationCanceledException) when (taskCancellationToken.IsCancellationRequested) + { + await _store.SetCancelledAsync(taskId, CancellationToken.None).ConfigureAwait(false); + } + catch (InputRequiredException) + { + var error = new JsonRpcErrorDetail + { + Code = (int)McpErrorCode.InvalidRequest, + Message = "MRTR and tasks cannot be composed via [McpServerTool] yet.", + }; + var errorJson = JsonSerializer.SerializeToElement(error, McpJsonUtilities.DefaultOptions.GetTypeInfo()); + await _store.SetFailedAsync(taskId, errorJson).ConfigureAwait(false); + } + catch (McpProtocolException mcpEx) + { + // SEP-2663 §186: protocol exceptions store as failed with JSON-RPC error shape. + var error = new JsonRpcErrorDetail { Code = (int)mcpEx.ErrorCode, Message = mcpEx.Message }; + var errorJson = JsonSerializer.SerializeToElement(error, McpJsonUtilities.DefaultOptions.GetTypeInfo()); + await _store.SetFailedAsync(taskId, errorJson).ConfigureAwait(false); + } + catch (Exception ex) + { + // Non-protocol exceptions are wrapped as CallToolResult { IsError = true }, + // matching Core's BuildInitialCallToolFilter behavior. + var errorResult = new CallToolResult + { + IsError = true, + Content = [new TextContentBlock + { + Text = ex is McpException + ? $"An error occurred invoking '{request.Params?.Name}': {ex.Message}" + : $"An error occurred invoking '{request.Params?.Name}'.", + }], + }; + var resultJson = JsonSerializer.SerializeToElement(errorResult, McpJsonUtilities.DefaultOptions.GetTypeInfo()); + await _store.SetCompletedAsync(taskId, resultJson).ConfigureAwait(false); + } + } + + private async ValueTask HandleGetTask(JsonRpcRequest request, CancellationToken cancellationToken) + { + GateToJuly2026OrLaterProtocol(request, TasksProtocol.MethodTasksGet); + GateToTasksCapability(request); + + var requestParams = request.Params?.Deserialize(McpTasksJsonContext.Default.GetTaskRequestParams) + ?? throw new McpProtocolException("Missing params for tasks/get", McpErrorCode.InvalidParams); + + var info = await _store.GetTaskAsync(requestParams.TaskId, cancellationToken).ConfigureAwait(false); + if (info is null) + { + throw new McpProtocolException($"Unknown task: '{requestParams.TaskId}'", McpErrorCode.InvalidParams); + } + + return JsonSerializer.SerializeToNode(ToGetTaskResult(info), McpTasksJsonContext.Default.GetTaskResult); + } + + private async ValueTask HandleUpdateTask(JsonRpcRequest request, CancellationToken cancellationToken) + { + GateToJuly2026OrLaterProtocol(request, TasksProtocol.MethodTasksUpdate); + GateToTasksCapability(request); + + var taskId = request.Params?["taskId"]?.GetValue() + ?? throw new McpProtocolException("Missing params.taskId for tasks/update", McpErrorCode.InvalidParams); + + // Deserialize inputResponses using Core's options which can access the internal + // InputResponsesCore backing property on RequestParams. The extension's source-gen + // context cannot see that internal member. + var inputResponses = request.Params?["inputResponses"]?.Deserialize( + McpJsonUtilities.DefaultOptions.GetTypeInfo>()) + ?? new Dictionary(); + + await _store.ResolveInputRequestsAsync(taskId, inputResponses, cancellationToken).ConfigureAwait(false); + + return JsonSerializer.SerializeToNode(new UpdateTaskResult(), McpTasksJsonContext.Default.UpdateTaskResult); + } + + private async ValueTask HandleCancelTask(JsonRpcRequest request, CancellationToken cancellationToken) + { + GateToJuly2026OrLaterProtocol(request, TasksProtocol.MethodTasksCancel); + GateToTasksCapability(request); + + var requestParams = request.Params?.Deserialize(McpTasksJsonContext.Default.CancelTaskRequestParams) + ?? throw new McpProtocolException("Missing params for tasks/cancel", McpErrorCode.InvalidParams); + + await _store.SetCancelledAsync(requestParams.TaskId, cancellationToken).ConfigureAwait(false); + + if (_cancellationSources.TryRemove(requestParams.TaskId, out var cts)) + { + cts.Cancel(); + cts.Dispose(); + } + + return JsonSerializer.SerializeToNode(new CancelTaskResult(), McpTasksJsonContext.Default.CancelTaskResult); + } + + private static void GateToJuly2026OrLaterProtocol(JsonRpcRequest request, string method) + { + if (!IsJuly2026OrLaterProtocolRequest(request)) + { + throw new McpProtocolException( + $"The method '{method}' requires a newer protocol revision that supports tasks " + + $"(the '{McpProtocolVersions.July2026ProtocolVersion}' revision or later); " + + $"the negotiated protocol version is '{request?.Context?.ProtocolVersion ?? "(none)"}'.", + McpErrorCode.MethodNotFound); + } + } + + private static void GateToTasksCapability(JsonRpcRequest request) + { + if (!HasTaskExtensionOptIn(request)) + { + throw CreateMissingTasksCapabilityException(); + } + } + + private static MissingRequiredClientCapabilityException CreateMissingTasksCapabilityException() => + new( + new ClientCapabilities + { + Extensions = new Dictionary + { + [TasksProtocol.ExtensionId] = new JsonObject(), + }, + }, + $"The request requires the '{TasksProtocol.ExtensionId}' client extension capability."); + + private static bool HasTaskExtensionOptIn(JsonRpcRequest request) => + request.Context?.ClientCapabilities?.Extensions?.ContainsKey(TasksProtocol.ExtensionId) is true || + request.Params?["_meta"]?[MetaKeys.ClientCapabilities]?["extensions"] is JsonObject extensions && + extensions.ContainsKey(TasksProtocol.ExtensionId); + + private static bool IsJuly2026OrLaterProtocolRequest(JsonRpcRequest? request) => + McpProtocolVersions.IsJuly2026OrLaterProtocolVersion(request?.Context?.ProtocolVersion); + + private static CreateTaskResult ToCreateTaskResult(McpTaskInfo info) => new() + { + TaskId = info.TaskId, + Status = info.Status, + CreatedAt = info.CreatedAt, + LastUpdatedAt = info.LastUpdatedAt, + TimeToLive = info.TimeToLive, + PollIntervalMs = info.PollIntervalMs, + StatusMessage = info.StatusMessage, + }; + + private static GetTaskResult ToGetTaskResult(McpTaskInfo info) => info.Status switch + { + McpTaskStatus.Working => new WorkingTaskResult + { + TaskId = info.TaskId, + CreatedAt = info.CreatedAt, + LastUpdatedAt = info.LastUpdatedAt, + TimeToLive = info.TimeToLive, + PollIntervalMs = info.PollIntervalMs, + StatusMessage = info.StatusMessage, + ResultType = "complete", + }, + McpTaskStatus.Completed => new CompletedTaskResult + { + TaskId = info.TaskId, + CreatedAt = info.CreatedAt, + LastUpdatedAt = info.LastUpdatedAt, + TimeToLive = info.TimeToLive, + PollIntervalMs = info.PollIntervalMs, + StatusMessage = info.StatusMessage, + Result = info.Result ?? throw new InvalidOperationException($"Task '{info.TaskId}' is completed but has no result."), + ResultType = "complete", + }, + McpTaskStatus.Failed => new FailedTaskResult + { + TaskId = info.TaskId, + CreatedAt = info.CreatedAt, + LastUpdatedAt = info.LastUpdatedAt, + TimeToLive = info.TimeToLive, + PollIntervalMs = info.PollIntervalMs, + StatusMessage = info.StatusMessage, + Error = info.Error ?? throw new InvalidOperationException($"Task '{info.TaskId}' is failed but has no error."), + ResultType = "complete", + }, + McpTaskStatus.Cancelled => new CancelledTaskResult + { + TaskId = info.TaskId, + CreatedAt = info.CreatedAt, + LastUpdatedAt = info.LastUpdatedAt, + TimeToLive = info.TimeToLive, + PollIntervalMs = info.PollIntervalMs, + StatusMessage = info.StatusMessage, + ResultType = "complete", + }, + McpTaskStatus.InputRequired => new InputRequiredTaskResult + { + TaskId = info.TaskId, + CreatedAt = info.CreatedAt, + LastUpdatedAt = info.LastUpdatedAt, + TimeToLive = info.TimeToLive, + PollIntervalMs = info.PollIntervalMs, + StatusMessage = info.StatusMessage, + InputRequests = info.InputRequests is IDictionary dict + ? dict + : info.InputRequests?.ToDictionary(kvp => kvp.Key, kvp => kvp.Value) ?? new Dictionary(), + ResultType = "complete", + }, + _ => throw new InvalidOperationException($"Unknown task status: {info.Status}"), + }; + } +} diff --git a/src/ModelContextProtocol.Extensions.Tasks/Server/McpTasksOptions.cs b/src/ModelContextProtocol.Extensions.Tasks/Server/McpTasksOptions.cs new file mode 100644 index 000000000..818a53fcf --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Tasks/Server/McpTasksOptions.cs @@ -0,0 +1,22 @@ +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; + +namespace ModelContextProtocol.Extensions.Tasks; + +/// +/// Configures server-side MCP Tasks behavior. +/// +public sealed class McpTasksOptions +{ + /// + /// Gets or sets the callback that selects task execution behavior for each tool call. + /// + /// + /// The default treats every tool as task-capable, preserving the behavior of + /// WithTasks. + /// The callback may inspect to select + /// behavior from tool metadata without requiring Core to reference the Tasks extension. + /// + public Func, McpTaskExecutionMode> ExecutionModeSelector { get; set; } = + static _ => McpTaskExecutionMode.Optional; +} diff --git a/src/ModelContextProtocol.Extensions.Tasks/Server/McpTasksServerExtensions.cs b/src/ModelContextProtocol.Extensions.Tasks/Server/McpTasksServerExtensions.cs new file mode 100644 index 000000000..74b227f5d --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Tasks/Server/McpTasksServerExtensions.cs @@ -0,0 +1,105 @@ +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.Text.Json; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.Extensions.Tasks; + +/// +/// Extension methods for task-aware server operations. +/// +public static class McpTasksServerExtensions +{ + /// + /// Sends a task status notification to the connected client. + /// + /// The server sending the notification. + /// The notification payload. + /// The cancellation token. + /// A task representing the send operation. + public static Task SendTaskStatusNotificationAsync( + this McpServer server, + TaskStatusNotificationParams notificationParams, + CancellationToken cancellationToken = default) + { +#if NET + ArgumentNullException.ThrowIfNull(server); + ArgumentNullException.ThrowIfNull(notificationParams); +#else + if (server is null) throw new ArgumentNullException(nameof(server)); + if (notificationParams is null) throw new ArgumentNullException(nameof(notificationParams)); +#endif + + return server.SendNotificationAsync( + TasksProtocol.NotificationTaskStatus, + notificationParams, + McpTasksJsonContext.Default.Options, + cancellationToken); + } + + internal static McpServer WithMcpTaskOutgoingRequestInterceptor( + this McpServer server, + string taskId, + IMcpTaskStore store) + { +#if NET + ArgumentNullException.ThrowIfNull(server); + ArgumentNullException.ThrowIfNull(taskId); + ArgumentNullException.ThrowIfNull(store); +#else + if (server is null) throw new ArgumentNullException(nameof(server)); + if (taskId is null) throw new ArgumentNullException(nameof(taskId)); + if (store is null) throw new ArgumentNullException(nameof(store)); +#endif + + return server.WithOutgoingRequestInterceptor(async (method, paramsNode, cancellationToken) => + { + var requestId = Guid.NewGuid().ToString("N"); + + var inputRequest = new InputRequest + { + Method = method, + Params = paramsNode is null + ? default + : JsonSerializer.SerializeToElement(paramsNode, McpJsonUtilities.DefaultOptions.GetTypeInfo()), + }; + + var tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + + void handler(InputResponseReceivedEventArgs args) + { + if (args.TaskId == taskId && args.RequestId == requestId) + { + tcs.TrySetResult(args.Response); + } + } + + store.InputResponseReceived += handler; + try + { + await store.SetInputRequestsAsync( + taskId, + new Dictionary { [requestId] = inputRequest }, + cancellationToken).ConfigureAwait(false); + +#if NET + var response = await tcs.Task.WaitAsync(cancellationToken).ConfigureAwait(false); +#else + using (cancellationToken.Register(() => tcs.TrySetCanceled(cancellationToken))) + { + var response = await tcs.Task.ConfigureAwait(false); + return JsonNode.Parse(response.RawValue.GetRawText()); + } +#endif + +#if NET + return JsonNode.Parse(response.RawValue.GetRawText()); +#endif + } + finally + { + store.InputResponseReceived -= handler; + } + }); + } +} diff --git a/src/ModelContextProtocol.Extensions.Tasks/TasksProtocol.cs b/src/ModelContextProtocol.Extensions.Tasks/TasksProtocol.cs new file mode 100644 index 000000000..44172666a --- /dev/null +++ b/src/ModelContextProtocol.Extensions.Tasks/TasksProtocol.cs @@ -0,0 +1,37 @@ +namespace ModelContextProtocol.Extensions.Tasks; + +/// +/// Provides constants for the MCP Tasks extension (SEP-2663). +/// +public static class TasksProtocol +{ + /// + /// The extension identifier for the MCP Tasks extension. + /// + public const string ExtensionId = "io.modelcontextprotocol/tasks"; + + /// + /// The name of the request method sent from the client to poll for task completion. + /// + public const string MethodTasksGet = "tasks/get"; + + /// + /// The name of the request method sent from the client to provide input responses to a task. + /// + public const string MethodTasksUpdate = "tasks/update"; + + /// + /// The name of the request method sent from the client to signal intent to cancel a task. + /// + public const string MethodTasksCancel = "tasks/cancel"; + + /// + /// The name of the notification sent by the server when a task's status changes. + /// + public const string NotificationTaskStatus = "notifications/tasks/status"; + + /// + /// The metadata key used to associate requests, responses, and notifications with a task. + /// + public const string MetaRelatedTask = "io.modelcontextprotocol/related-task"; +} diff --git a/src/ModelContextProtocol/McpRequestFilterBuilderExtensions.cs b/src/ModelContextProtocol/McpRequestFilterBuilderExtensions.cs index 8ee7fb064..db939c61b 100644 --- a/src/ModelContextProtocol/McpRequestFilterBuilderExtensions.cs +++ b/src/ModelContextProtocol/McpRequestFilterBuilderExtensions.cs @@ -42,6 +42,10 @@ public static IMcpRequestFilterBuilder AddListToolsFilter(this IMcpRequestFilter /// /// Adds a filter to the call tool handler pipeline. /// + /// + /// This ordinary call-tool filter runs inside all alternate-result call-tool filters. For a task-backed call, + /// it executes in the background after task creation and before the tool. + /// /// The request filter builder instance. /// The filter function that wraps the handler. /// The builder provided in . @@ -165,6 +169,7 @@ public static IMcpRequestFilterBuilder AddUnsubscribeFromResourcesFilter(this IM /// The request filter builder instance. /// The filter function that wraps the handler. /// The builder provided in . + [Obsolete(Obsoletions.DeprecatedLogging_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public static IMcpRequestFilterBuilder AddSetLoggingLevelFilter(this IMcpRequestFilterBuilder builder, McpRequestFilter filter) { Throw.IfNull(builder); diff --git a/src/ModelContextProtocol/McpServerBuilderExtensions.cs b/src/ModelContextProtocol/McpServerBuilderExtensions.cs index da63dc31d..7e24bc5c0 100644 --- a/src/ModelContextProtocol/McpServerBuilderExtensions.cs +++ b/src/ModelContextProtocol/McpServerBuilderExtensions.cs @@ -859,6 +859,51 @@ public static IMcpServerBuilder WithUnsubscribeFromResourcesHandler(this IMcpSer return builder; } + /// + /// Configures a handler for subscriptions/listen requests (SEP-2575), taking over the long-lived + /// subscription stream introduced by the 2026-07-28 protocol revision. + /// + /// The server builder instance. + /// The handler that owns the subscription stream for the lifetime of the request. + /// The builder provided in . + /// is . + /// + /// + /// subscriptions/listen is a long-lived request whose held-open response is a solicited + /// server-to-client stream. Providing a handler here lets a server author own that stream to implement + /// custom subscription kinds, application-driven resources/updated delivery, or subscriptions backed + /// by their own event source. It is especially useful for stateless Streamable HTTP, where unsolicited + /// notifications are dropped but the listen request's response stream can still carry notifications for the + /// duration of the request. + /// + /// + /// This is a full replacement for the SDK's built-in subscriptions/listen handling. When set, the + /// handler alone is responsible for sending exactly one + /// before any events, tagging every + /// streamed notification with the listen request id under _meta[], + /// staying active until the supplied is cancelled, and returning + /// when it completes. See + /// for the full contract. + /// + /// + /// Unlike , this method intentionally does not advertise any + /// server capabilities on the author's behalf. The set of notifications a listen handler honors is decided + /// at runtime and can include custom kinds not represented by a capability flag, so the author must + /// configure only the capabilities their handler will actually deliver. Advertised capabilities must match + /// what the handler delivers. + /// + /// + public static IMcpServerBuilder WithSubscriptionsListenHandler(this IMcpServerBuilder builder, McpRequestHandler handler) + { + Throw.IfNull(builder); + + builder.Services.Configure(options => + { + options.Handlers.SubscriptionsListenHandler = handler; + }); + return builder; + } + /// /// Configures a handler for processing logging level change requests from clients. /// @@ -878,6 +923,7 @@ public static IMcpServerBuilder WithUnsubscribeFromResourcesHandler(this IMcpSer /// most recently set level. /// /// + [Obsolete(Obsoletions.DeprecatedLogging_Message, DiagnosticId = Obsoletions.Deprecated_DiagnosticId, UrlFormat = Obsoletions.Deprecated_Url)] public static IMcpServerBuilder WithSetLoggingLevelHandler(this IMcpServerBuilder builder, McpRequestHandler handler) { Throw.IfNull(builder); diff --git a/src/ModelContextProtocol/McpServerOptionsSetup.cs b/src/ModelContextProtocol/McpServerOptionsSetup.cs index 5977fae7e..c46854460 100644 --- a/src/ModelContextProtocol/McpServerOptionsSetup.cs +++ b/src/ModelContextProtocol/McpServerOptionsSetup.cs @@ -9,12 +9,10 @@ namespace ModelContextProtocol; /// The individually registered tools. /// The individually registered prompts. /// The individually registered resources. -/// The optional task store registered in DI. internal sealed class McpServerOptionsSetup( IEnumerable serverTools, IEnumerable serverPrompts, - IEnumerable serverResources, - IMcpTaskStore? taskStore = null) : IConfigureOptions + IEnumerable serverResources) : IConfigureOptions { /// /// Configures the given McpServerOptions instance by setting server information @@ -25,8 +23,6 @@ public void Configure(McpServerOptions options) { Throw.IfNull(options); - options.TaskStore ??= taskStore; - // Collect all of the provided tools into a tools collection. If the options already has // a collection, add to it, otherwise create a new one. We want to maintain the identity // of an existing collection in case someone has provided their own derived type, wants diff --git a/src/ModelContextProtocol/ModelContextProtocol.csproj b/src/ModelContextProtocol/ModelContextProtocol.csproj index 231eb073a..36c6a1736 100644 --- a/src/ModelContextProtocol/ModelContextProtocol.csproj +++ b/src/ModelContextProtocol/ModelContextProtocol.csproj @@ -1,4 +1,4 @@ - + net10.0;net9.0;net8.0;netstandard2.0 @@ -8,14 +8,24 @@ .NET SDK for the Model Context Protocol (MCP) with hosting and dependency injection extensions. README.md True - + $(NoWarn);MCPEXP001 + + $(NoWarn);MCP9006 + + $(NoWarn);CS0436 true + + + $(NoWarn);CS0436 + + diff --git a/src/ModelContextProtocol/Server/DistributedCacheEventStreamStoreOptions.cs b/src/ModelContextProtocol/Server/DistributedCacheEventStreamStoreOptions.cs index f434e12c3..227bf132e 100644 --- a/src/ModelContextProtocol/Server/DistributedCacheEventStreamStoreOptions.cs +++ b/src/ModelContextProtocol/Server/DistributedCacheEventStreamStoreOptions.cs @@ -5,6 +5,7 @@ namespace ModelContextProtocol.Server; /// /// Configuration options for . /// +[Obsolete(Obsoletions.LegacyStatefulHttp_Message, DiagnosticId = Obsoletions.LegacyStatefulHttp_DiagnosticId, UrlFormat = Obsoletions.LegacyStatefulHttp_Url)] public sealed class DistributedCacheEventStreamStoreOptions { /// diff --git a/src/PACKAGE.md b/src/PACKAGE.md index d849a8f83..b3c1d9143 100644 --- a/src/PACKAGE.md +++ b/src/PACKAGE.md @@ -4,9 +4,11 @@ The official C# SDK for the [Model Context Protocol](https://modelcontextprotocol.io/), enabling .NET applications, services, and libraries to implement and interact with MCP clients and servers. Please visit the [API documentation](https://csharp.sdk.modelcontextprotocol.io/api/ModelContextProtocol.html) for more details on available functionality. +See the [release notes](https://github.com/modelcontextprotocol/csharp-sdk/releases/tag/v2.2.0) for what's new in this version. + ## Packages -This SDK consists of three main packages: +The SDK packages are: - **[ModelContextProtocol.Core](https://www.nuget.org/packages/ModelContextProtocol.Core)** [![NuGet version](https://img.shields.io/nuget/v/ModelContextProtocol.Core.svg)](https://www.nuget.org/packages/ModelContextProtocol.Core) - For projects that only need to use the client or low-level server APIs and want the minimum number of dependencies. @@ -14,6 +16,10 @@ This SDK consists of three main packages: - **[ModelContextProtocol.AspNetCore](https://www.nuget.org/packages/ModelContextProtocol.AspNetCore)** [![NuGet version](https://img.shields.io/nuget/v/ModelContextProtocol.AspNetCore.svg)](https://www.nuget.org/packages/ModelContextProtocol.AspNetCore) - The library for HTTP-based MCP servers. References `ModelContextProtocol`. +- **[ModelContextProtocol.Extensions.Apps](https://www.nuget.org/packages/ModelContextProtocol.Extensions.Apps)** [![NuGet version](https://img.shields.io/nuget/v/ModelContextProtocol.Extensions.Apps.svg)](https://www.nuget.org/packages/ModelContextProtocol.Extensions.Apps) - MCP Apps extension for building interactive UI applications that render inside MCP hosts. + +- **[ModelContextProtocol.Extensions.Tasks](https://www.nuget.org/packages/ModelContextProtocol.Extensions.Tasks)** [![NuGet version](https://img.shields.io/nuget/v/ModelContextProtocol.Extensions.Tasks.svg)](https://www.nuget.org/packages/ModelContextProtocol.Extensions.Tasks) - MCP Tasks extension for running long-running tool invocations asynchronously with status polling and input requests. + ## Getting Started To get started, see the [Getting Started](https://csharp.sdk.modelcontextprotocol.io/concepts/getting-started.html) guide for installation instructions, package-selection guidance, and complete examples for both clients and servers. diff --git a/tests/Common/Utils/NodeHelpers.cs b/tests/Common/Utils/NodeHelpers.cs index 94ae206ab..98c225dd9 100644 --- a/tests/Common/Utils/NodeHelpers.cs +++ b/tests/Common/Utils/NodeHelpers.cs @@ -1,5 +1,7 @@ using System.Diagnostics; using System.Runtime.InteropServices; +using System.Text; +using System.Text.RegularExpressions; namespace ModelContextProtocol.Tests.Utils; @@ -49,9 +51,12 @@ public static void EnsureNpmDependenciesInstalled() var repoRoot = FindRepoRoot(); var nodeModulesPath = Path.Combine(repoRoot, "node_modules"); + var lockFilePath = Path.Combine(repoRoot, "package-lock.json"); - // Use 'npm ci' if node_modules doesn't exist, otherwise assume it's up to date. - if (!Directory.Exists(nodeModulesPath)) + // Run 'npm ci' if node_modules doesn't exist or is outdated + // (package-lock.json is newer than node_modules). + if (!Directory.Exists(nodeModulesPath) || + File.GetLastWriteTimeUtc(lockFilePath) > Directory.GetLastWriteTimeUtc(nodeModulesPath)) { var startInfo = NpmStartInfo("ci", repoRoot); using var process = Process.Start(startInfo) @@ -75,11 +80,27 @@ public static void EnsureNpmDependenciesInstalled() /// /// The name of the binary in node_modules/.bin (e.g. "conformance"). /// The arguments to pass to the binary. + /// + /// When (the default) and the MCP_CONFORMANCE_PROTOCOL_VERSION + /// environment variable is set, a "--spec-version <value>" argument is appended. + /// Pass for scenarios that pin their own spec version (e.g. the + /// caching scenario specific to the 2026-07-28 protocol) to avoid a conflicting duplicate flag. + /// /// A configured ProcessStartInfo for running the binary. - public static ProcessStartInfo ConformanceTestStartInfo(string arguments) + public static ProcessStartInfo ConformanceTestStartInfo(string arguments, bool appendProtocolVersionFromEnv = true) { EnsureNpmDependenciesInstalled(); + // If MCP_CONFORMANCE_PROTOCOL_VERSION is set, pass it as --spec-version to the runner. + if (appendProtocolVersionFromEnv) + { + var protocolVersion = Environment.GetEnvironmentVariable("MCP_CONFORMANCE_PROTOCOL_VERSION"); + if (!string.IsNullOrEmpty(protocolVersion)) + { + arguments += $" --spec-version {protocolVersion}"; + } + } + var repoRoot = FindRepoRoot(); var binPath = Path.Combine(repoRoot, "node_modules", ".bin", "conformance"); @@ -157,6 +178,373 @@ public static bool IsNodeInstalled() } } + /// + /// Checks whether the SEP-2243 conformance scenarios are available in the installed + /// conformance package. + /// + public static bool HasSep2243Scenarios() + => HasInstalledConformanceScenarios( + "http-standard-headers", + "http-invalid-tool-headers", + "http-header-validation", + "http-custom-header-server-validation"); + + /// + /// Checks whether the SEP-2575 request-metadata client conformance scenario is available + /// in the installed conformance package. + /// + public static bool HasRequestMetadataScenario() + => HasInstalledConformanceScenario("request-metadata"); + + /// + /// Checks whether the installed conformance package contains a spec-conformant + /// http-custom-headers scenario. Prereleases 0.2.0-alpha.5 through 0.2.0-alpha.7 + /// annotated a number-typed parameter with x-mcp-header, which SEP-2243 + /// forbids; a conformant client excludes that tool, so every positive check in the + /// scenario fails. Conformance PR #371 fixed the scenario and shipped it in 0.2.0-alpha.8, + /// so this gate requires at least that version. Unlike , + /// this comparison honors the semver prerelease so older 0.2.0 prereleases are skipped + /// rather than failing spuriously. + /// + public static bool HasConformantCustomHeadersScenario() + => IsInstalledConformanceVersionAtLeast("0.2.0-alpha.8"); + + /// + /// Checks whether the SEP-2549 "caching" conformance scenario (added in conformance + /// PR #275) is available, by reading the installed conformance package version + /// from node_modules. The caching scenario was introduced in conformance package 0.2.0. + /// Reading the installed version (rather than the pinned version in package.json) means + /// this also returns when a newer private build has been installed + /// locally via npm install --no-save <path-to-conformance>. + /// + public static bool HasCachingScenario() + => HasInstalledConformanceScenario("caching"); + + /// + /// Checks whether all named conformance scenarios are present in the installed + /// @modelcontextprotocol/conformance bundle. This is intentionally based on the + /// installed scenario list rather than the package version so prerelease/private builds are + /// gated by the scenarios they actually contain. + /// + private static bool HasInstalledConformanceScenarios(params string[] scenarioNames) + => ReadInstalledConformanceBundle() is { } bundle + && scenarioNames.All(scenarioName => HasInstalledConformanceScenario(bundle, scenarioName)); + + private static bool HasInstalledConformanceScenario(string scenarioName) + => ReadInstalledConformanceBundle() is { } bundle + && HasInstalledConformanceScenario(bundle, scenarioName); + + private static bool HasInstalledConformanceScenario(string bundle, string scenarioName) + => bundle.Contains($"`{scenarioName}`", StringComparison.Ordinal) || + bundle.Contains($"\"{scenarioName}\"", StringComparison.Ordinal) || + bundle.Contains($"'{scenarioName}'", StringComparison.Ordinal); + + private static string? ReadInstalledConformanceBundle() + { + try + { + var repoRoot = FindRepoRoot(); + var bundlePath = Path.Combine( + repoRoot, "node_modules", "@modelcontextprotocol", "conformance", "dist", "index.js"); + + // This is a skip gate for scenario-conditional conformance tests, so it must stay + // side-effect-free. If the conformance package isn't installed, report no bundle (the + // scenario is simply gated off); the actual scenario run path restores npm dependencies + // separately via ConformanceTestStartInfo. + if (!File.Exists(bundlePath)) + { + return null; + } + + return File.ReadAllText(bundlePath); + } + catch + { + return null; + } + } + + /// + /// Returns when the conformance package installed in node_modules + /// has a semver precedence greater than or equal to , + /// honoring the prerelease component (e.g. "0.2.0-alpha.8"). Returns + /// when no version can be determined. + /// + private static bool IsInstalledConformanceVersionAtLeast(string minimumVersion) + { + var installed = GetInstalledConformanceVersionString(); + return installed is not null && CompareSemVer(installed, minimumVersion) >= 0; + } + + /// + /// Reads the raw version string of the conformance package installed in node_modules, + /// preserving any prerelease/build suffix. Returns if it cannot be + /// determined. + /// + private static string? GetInstalledConformanceVersionString() + { + try + { + var repoRoot = FindRepoRoot(); + var packageJsonPath = Path.Combine( + repoRoot, "node_modules", "@modelcontextprotocol", "conformance", "package.json"); + + if (!File.Exists(packageJsonPath)) + { + return null; + } + + using var json = System.Text.Json.JsonDocument.Parse(File.ReadAllText(packageJsonPath)); + if (json.RootElement.TryGetProperty("version", out var versionElement)) + { + return versionElement.GetString(); + } + + return null; + } + catch + { + return null; + } + } + + /// + /// Compares two semantic version strings by precedence, honoring the prerelease component + /// per the SemVer 2.0.0 rules used here (numeric identifiers compare numerically, a version + /// with a prerelease has lower precedence than the same version without one, and a shorter + /// set of prerelease identifiers has lower precedence when all preceding ones are equal). + /// Build metadata (after '+') is ignored. Returns a negative value when + /// precedes , zero when equal, and a positive value otherwise. + /// + private static int CompareSemVer(string a, string b) + { + var (coreA, preA) = SplitSemVer(a); + var (coreB, preB) = SplitSemVer(b); + + var coreCompare = coreA.CompareTo(coreB); + if (coreCompare != 0) + { + return coreCompare; + } + + // A version without a prerelease outranks one with a prerelease. + if (preA.Length == 0 && preB.Length == 0) + { + return 0; + } + if (preA.Length == 0) + { + return 1; + } + if (preB.Length == 0) + { + return -1; + } + + var count = Math.Min(preA.Length, preB.Length); + for (var i = 0; i < count; i++) + { + var idA = preA[i]; + var idB = preB[i]; + var numA = int.TryParse(idA, out var na); + var numB = int.TryParse(idB, out var nb); + + int cmp; + if (numA && numB) + { + cmp = na.CompareTo(nb); + } + else if (numA) + { + // Numeric identifiers always have lower precedence than alphanumeric ones. + cmp = -1; + } + else if (numB) + { + cmp = 1; + } + else + { + cmp = string.CompareOrdinal(idA, idB); + } + + if (cmp != 0) + { + return cmp; + } + } + + return preA.Length.CompareTo(preB.Length); + } + + /// + /// Splits a semver string into its numeric core (major.minor.patch) and its prerelease + /// identifiers, ignoring any build metadata after '+'. Missing core components default to 0. + /// + private static (Version Core, string[] Prerelease) SplitSemVer(string version) + { + var withoutBuild = version.Split(new[] { '+' }, 2)[0]; + var parts = withoutBuild.Split(new[] { '-' }, 2); + var prerelease = parts.Length > 1 && parts[1].Length > 0 + ? parts[1].Split('.') + : Array.Empty(); + + var coreParts = parts[0].Split('.'); + int Part(int index) => index < coreParts.Length && int.TryParse(coreParts[index], out var v) ? v : 0; + var core = new Version(Part(0), Part(1), Part(2)); + + return (core, prerelease); + } + + + /// whether it succeeded along with the captured stdout/stderr. Centralizes the process + /// plumbing (output capture, a 5-minute timeout, and the Windows libuv-shutdown fallback) + /// shared by the server-side conformance tests. + /// + /// Arguments to pass to the conformance runner. + /// Optional callback invoked for each captured stdout/stderr line. + /// + /// Forwarded to . + /// + /// Token used to cancel the run. + public static async Task<(bool Success, string Output, string Error)> RunServerConformanceAsync( + string arguments, + Action? onLine = null, + bool appendProtocolVersionFromEnv = true, + CancellationToken cancellationToken = default) + { + var startInfo = ConformanceTestStartInfo(arguments, appendProtocolVersionFromEnv); + + var outputBuilder = new StringBuilder(); + var errorBuilder = new StringBuilder(); + + using var process = new Process { StartInfo = startInfo }; + + // Protect callbacks with try/catch so a callback that throws on a background thread + // (e.g. ITestOutputHelper after the test completes) does not crash the test host. + DataReceivedEventHandler outputHandler = (sender, e) => + { + if (e.Data != null) + { + try { onLine?.Invoke(e.Data); } catch { } + outputBuilder.AppendLine(e.Data); + } + }; + + DataReceivedEventHandler errorHandler = (sender, e) => + { + if (e.Data != null) + { + try { onLine?.Invoke(e.Data); } catch { } + errorBuilder.AppendLine(e.Data); + } + }; + + process.OutputDataReceived += outputHandler; + process.ErrorDataReceived += errorHandler; + + process.Start(); + process.BeginOutputReadLine(); + process.BeginErrorReadLine(); + + using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken); + cts.CancelAfter(TimeSpan.FromMinutes(5)); + try + { +#if NET + await process.WaitForExitAsync(cts.Token); +#else + // net472 lacks the CancellationToken overload; fall back to the timeout-based polyfill + // extension and surface a timeout the same way the current target-framework path does. + await process.WaitForExitAsync(TimeSpan.FromMinutes(5)); + if (!process.HasExited) + { + throw new OperationCanceledException(); + } +#endif + } + catch (OperationCanceledException) + { +#if NET + process.Kill(entireProcessTree: true); +#else + process.Kill(); +#endif + process.OutputDataReceived -= outputHandler; + process.ErrorDataReceived -= errorHandler; + return ( + false, + outputBuilder.ToString(), + errorBuilder.ToString() + "\nProcess timed out after 5 minutes and was killed."); + } + + process.OutputDataReceived -= outputHandler; + process.ErrorDataReceived -= errorHandler; + + var stdoutText = outputBuilder.ToString(); + var stderrText = errorBuilder.ToString(); + + // The Node.js conformance runner can crash during cleanup on Windows with a libuv + // assertion ("!(handle->flags & UV_HANDLE_CLOSING)") that produces a non-zero exit + // code even though every conformance check passed. When that happens, fall back to + // parsing the "Test Results:" summary in stdout to decide success. + bool success = process.ExitCode == 0 || ConformanceOutputIndicatesSuccess(stdoutText); + + return (success, stdoutText, stderrText); + } + + /// + /// Parses the conformance runner output for a "Test Results:" line such as + /// "Passed: 3/3, 0 failed, 0 warnings" and returns true when all checks passed + /// and none failed. + /// + private static bool ConformanceOutputIndicatesSuccess(string output) + { + // Match lines like "Passed: 3/3, 0 failed, 0 warnings" + var match = Regex.Match(output, @"Passed:\s*(\d+)/(\d+),\s*(\d+)\s*failed"); + if (!match.Success) + { + return false; + } + + int passed = int.Parse(match.Groups[1].Value); + int total = int.Parse(match.Groups[2].Value); + int failed = int.Parse(match.Groups[3].Value); + + return passed == total && failed == 0 && total > 0; + } + + /// + /// Checks whether the SEP-2322 (Multi Round-Trip Requests / InputRequiredResult) + /// conformance scenarios are available in the installed conformance package. + /// + public static bool HasMrtrScenarios() + => HasInstalledConformanceScenarios( + "input-required-result-basic-elicitation", + "input-required-result-basic-sampling", + "input-required-result-basic-list-roots", + "input-required-result-request-state", + "input-required-result-multiple-input-requests", + "input-required-result-multi-round", + "input-required-result-missing-input-response", + "input-required-result-non-tool-request", + "input-required-result-result-type", + "input-required-result-unsupported-methods", + "input-required-result-tampered-state", + "input-required-result-capability-check", + "input-required-result-ignore-extra-params", + "input-required-result-validate-input"); + + /// + /// Checks whether the SEP-2663 Tasks extension server scenarios are available in the + /// installed conformance package. + /// + public static bool HasTasksExtensionScenarios() + => HasInstalledConformanceScenarios( + "tasks-wire-fields", + "tasks-request-state-removal", + "tasks-mrtr-input"); + private static ProcessStartInfo NpmStartInfo(string arguments, string workingDirectory) { if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) diff --git a/tests/Common/Utils/ServerMessageTracker.cs b/tests/Common/Utils/ServerMessageTracker.cs new file mode 100644 index 000000000..66a80c681 --- /dev/null +++ b/tests/Common/Utils/ServerMessageTracker.cs @@ -0,0 +1,95 @@ +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.Collections.Concurrent; +using System.Text.Json.Nodes; +using Xunit; + +namespace ModelContextProtocol.Tests.Utils; + +/// +/// Tracks MRTR protocol mode via incoming and outgoing message filters. +/// Used by MRTR tests to verify the correct protocol mode (MRTR vs legacy) was used. +/// +internal sealed class ServerMessageTracker +{ + private static readonly HashSet LegacyMrtrMethods = + [ + RequestMethods.ElicitationCreate, + RequestMethods.SamplingCreateMessage, + RequestMethods.RootsList, + ]; + + private readonly ConcurrentBag _legacyRequestMethods = []; + private int _mrtrRetryCount; + private int _incompleteResultCount; + + /// + /// Adds incoming and outgoing message filters to track MRTR protocol usage. + /// Call this in services.Configure<McpServerOptions> or AddMcpServer callbacks. + /// + public void AddFilters(McpMessageFilters messageFilters) + { + // Track outgoing legacy JSON-RPC requests and InputRequiredResult responses. + messageFilters.OutgoingFilters.Add(next => async (context, cancellationToken) => + { + if (context.JsonRpcMessage is JsonRpcRequest request && LegacyMrtrMethods.Contains(request.Method)) + { + _legacyRequestMethods.Add(request.Method); + } + else if (context.JsonRpcMessage is JsonRpcResponse response && + response.Result is JsonObject resultObj && + resultObj.TryGetPropertyValue("resultType", out var resultTypeNode) && + resultTypeNode?.GetValue() == "input_required") + { + Interlocked.Increment(ref _incompleteResultCount); + } + + await next(context, cancellationToken); + }); + + // Track incoming MRTR retries (requests with inputResponses or requestState in params). + messageFilters.IncomingFilters.Add(next => async (context, cancellationToken) => + { + if (context.JsonRpcMessage is JsonRpcRequest request && + request.Params is JsonObject paramsObj && + (paramsObj.ContainsKey("inputResponses") || paramsObj.ContainsKey("requestState"))) + { + Interlocked.Increment(ref _mrtrRetryCount); + } + + await next(context, cancellationToken); + }); + } + + /// + /// Asserts that MRTR was used: at least one InputRequiredResult response was sent + /// and no legacy JSON-RPC requests (elicitation/create, sampling/createMessage, roots/list) were sent. + /// + public void AssertMrtrUsed() + { + Assert.True(_incompleteResultCount > 0, + "Expected at least one InputRequiredResult response (MRTR mode), but none were detected."); + Assert.Empty(_legacyRequestMethods); + } + + /// + /// Asserts that MRTR was used at least once (at least one InputRequiredResult response was sent), + /// independent of whether the session also issued any legacy server-to-client requests. + /// + public void AssertMrtrUsedAtLeastOnce() + { + Assert.True(_incompleteResultCount > 0, + "Expected at least one InputRequiredResult response (MRTR mode), but none were detected."); + } + + /// + /// Asserts that legacy mode was used: at least one legacy JSON-RPC request was sent + /// and no MRTR retries or InputRequiredResult responses were detected. + /// + public void AssertMrtrNotUsed() + { + Assert.NotEmpty(_legacyRequestMethods); + Assert.Equal(0, _mrtrRetryCount); + Assert.Equal(0, _incompleteResultCount); + } +} diff --git a/tests/Common/Utils/TestServerTransport.cs b/tests/Common/Utils/TestServerTransport.cs index 43cd5c262..ed9b6ee72 100644 --- a/tests/Common/Utils/TestServerTransport.cs +++ b/tests/Common/Utils/TestServerTransport.cs @@ -46,14 +46,6 @@ public async Task SendMessageAsync(JsonRpcMessage message, CancellationToken can await SamplingAsync(request, cancellationToken); else if (request.Method == RequestMethods.ElicitationCreate) await ElicitAsync(request, cancellationToken); - else if (request.Method == RequestMethods.TasksGet) - await TasksGetAsync(request, cancellationToken); - else if (request.Method == RequestMethods.TasksResult) - await TasksResultAsync(request, cancellationToken); - else if (request.Method == RequestMethods.TasksList) - await TasksListAsync(request, cancellationToken); - else if (request.Method == RequestMethods.TasksCancel) - await TasksCancelAsync(request, cancellationToken); else await WriteMessageAsync(request, cancellationToken); } @@ -79,161 +71,21 @@ await WriteMessageAsync(new JsonRpcResponse private async Task SamplingAsync(JsonRpcRequest request, CancellationToken cancellationToken) { - // Check if the request is task-augmented (has Task metadata) - var requestParams = JsonSerializer.Deserialize(request.Params, McpJsonUtilities.DefaultOptions); - if (requestParams?.Task is not null && MockTask is not null) - { - // Return a task-augmented response - await WriteMessageAsync(new JsonRpcResponse - { - Id = request.Id, - Result = JsonSerializer.SerializeToNode(new CreateTaskResult { Task = MockTask }, McpJsonUtilities.DefaultOptions), - }, cancellationToken); - } - else - { - // Return a normal sampling response - await WriteMessageAsync(new JsonRpcResponse - { - Id = request.Id, - Result = JsonSerializer.SerializeToNode(new CreateMessageResult { Content = [new TextContentBlock { Text = "" }], Model = "model" }, McpJsonUtilities.DefaultOptions), - }, cancellationToken); - } - } - - private async Task ElicitAsync(JsonRpcRequest request, CancellationToken cancellationToken) - { - // Check if the request is task-augmented (has Task metadata) - var requestParams = JsonSerializer.Deserialize(request.Params, McpJsonUtilities.DefaultOptions); - if (requestParams?.Task is not null && MockTask is not null) - { - // Return a task-augmented response - await WriteMessageAsync(new JsonRpcResponse - { - Id = request.Id, - Result = JsonSerializer.SerializeToNode(new CreateTaskResult { Task = MockTask }, McpJsonUtilities.DefaultOptions), - }, cancellationToken); - } - else - { - // Return a normal elicitation response - await WriteMessageAsync(new JsonRpcResponse - { - Id = request.Id, - Result = JsonSerializer.SerializeToNode(new ElicitResult { Action = "decline" }, McpJsonUtilities.DefaultOptions), - }, cancellationToken); - } - } - - /// - /// Gets or sets the task to return from tasks/get requests. - /// - public McpTask? MockTask { get; set; } - - /// - /// Gets or sets the result to return from tasks/result requests. - /// - public object? MockTaskResult { get; set; } - - /// - /// Gets or sets the list of tasks to return from tasks/list requests. - /// - public McpTask[]? MockTaskList { get; set; } - - private async Task TasksGetAsync(JsonRpcRequest request, CancellationToken cancellationToken) - { - var task = MockTask ?? new McpTask - { - TaskId = "test-task-id", - Status = McpTaskStatus.Completed, - CreatedAt = DateTimeOffset.UtcNow.AddMinutes(-5), - LastUpdatedAt = DateTimeOffset.UtcNow, - }; - + // Return a normal sampling response await WriteMessageAsync(new JsonRpcResponse { Id = request.Id, - Result = JsonSerializer.SerializeToNode(new GetTaskResult - { - TaskId = task.TaskId, - Status = task.Status, - StatusMessage = task.StatusMessage, - CreatedAt = task.CreatedAt, - LastUpdatedAt = task.LastUpdatedAt, - TimeToLive = task.TimeToLive, - PollInterval = task.PollInterval - }, McpJsonUtilities.DefaultOptions), + Result = JsonSerializer.SerializeToNode(new CreateMessageResult { Content = [new TextContentBlock { Text = "" }], Model = "model" }, McpJsonUtilities.DefaultOptions), }, cancellationToken); } - private async Task TasksResultAsync(JsonRpcRequest request, CancellationToken cancellationToken) - { - var result = MockTaskResult ?? new CreateMessageResult - { - Content = [new TextContentBlock { Text = "Task result" }], - Model = "test-model" - }; - - await WriteMessageAsync(new JsonRpcResponse - { - Id = request.Id, - Result = JsonSerializer.SerializeToNode(result, McpJsonUtilities.DefaultOptions), - }, cancellationToken); - } - - private async Task TasksListAsync(JsonRpcRequest request, CancellationToken cancellationToken) - { - var tasks = MockTaskList ?? [ - new McpTask - { - TaskId = "task-1", - Status = McpTaskStatus.Completed, - CreatedAt = DateTimeOffset.UtcNow.AddMinutes(-5), - LastUpdatedAt = DateTimeOffset.UtcNow, - }, - new McpTask - { - TaskId = "task-2", - Status = McpTaskStatus.Working, - CreatedAt = DateTimeOffset.UtcNow.AddMinutes(-3), - LastUpdatedAt = DateTimeOffset.UtcNow, - } - ]; - - await WriteMessageAsync(new JsonRpcResponse - { - Id = request.Id, - Result = JsonSerializer.SerializeToNode(new ListTasksResult - { - Tasks = tasks, - }, McpJsonUtilities.DefaultOptions), - }, cancellationToken); - } - - private async Task TasksCancelAsync(JsonRpcRequest request, CancellationToken cancellationToken) + private async Task ElicitAsync(JsonRpcRequest request, CancellationToken cancellationToken) { - var task = MockTask ?? new McpTask - { - TaskId = "test-task-id", - Status = McpTaskStatus.Cancelled, - StatusMessage = "Task cancelled by request", - CreatedAt = DateTimeOffset.UtcNow.AddMinutes(-5), - LastUpdatedAt = DateTimeOffset.UtcNow, - }; - + // Return a normal elicitation response await WriteMessageAsync(new JsonRpcResponse { Id = request.Id, - Result = JsonSerializer.SerializeToNode(new CancelMcpTaskResult - { - TaskId = task.TaskId, - Status = McpTaskStatus.Cancelled, - StatusMessage = task.StatusMessage ?? "Task cancelled", - CreatedAt = task.CreatedAt, - LastUpdatedAt = DateTimeOffset.UtcNow, - TimeToLive = task.TimeToLive, - PollInterval = task.PollInterval - }, McpJsonUtilities.DefaultOptions), + Result = JsonSerializer.SerializeToNode(new ElicitResult { Action = "decline" }, McpJsonUtilities.DefaultOptions), }, cancellationToken); } diff --git a/tests/Directory.Build.props b/tests/Directory.Build.props index 1071ec394..b4a79a31e 100644 --- a/tests/Directory.Build.props +++ b/tests/Directory.Build.props @@ -3,9 +3,12 @@ True - + $(NoWarn);MCPEXP001 $(NoWarn);MCP9004 + + $(NoWarn);MCP9005 diff --git a/tests/ModelContextProtocol.AotCompatibility.TestApp/ModelContextProtocol.AotCompatibility.TestApp.csproj b/tests/ModelContextProtocol.AotCompatibility.TestApp/ModelContextProtocol.AotCompatibility.TestApp.csproj index 2b505f9ed..a8ab66edf 100644 --- a/tests/ModelContextProtocol.AotCompatibility.TestApp/ModelContextProtocol.AotCompatibility.TestApp.csproj +++ b/tests/ModelContextProtocol.AotCompatibility.TestApp/ModelContextProtocol.AotCompatibility.TestApp.csproj @@ -7,18 +7,20 @@ true false - - $(NoWarn);MCPEXP001 + + $(NoWarn);MCPEXP001;MCPEXP003 + + diff --git a/tests/ModelContextProtocol.AotCompatibility.TestApp/Program.cs b/tests/ModelContextProtocol.AotCompatibility.TestApp/Program.cs index 687d78e4e..708cd9361 100644 --- a/tests/ModelContextProtocol.AotCompatibility.TestApp/Program.cs +++ b/tests/ModelContextProtocol.AotCompatibility.TestApp/Program.cs @@ -1,17 +1,20 @@ +using Microsoft.Extensions.DependencyInjection; using ModelContextProtocol.Client; +using ModelContextProtocol.Extensions.Apps; using ModelContextProtocol.Protocol; using ModelContextProtocol.Server; using System.IO.Pipelines; Pipe clientToServerPipe = new(), serverToClientPipe = new(); -// Create a server using a stream-based transport over an in-memory pipe. -await using McpServer server = McpServer.Create( - new StreamServerTransport(clientToServerPipe.Reader.AsStream(), serverToClientPipe.Writer.AsStream()), - new McpServerOptions() - { - ToolCollection = [McpServerTool.Create((string arg) => $"Echo: {arg}", new() { Name = "Echo" })] - }); +var services = new ServiceCollection(); +services.AddMcpServer() + .WithStreamServerTransport(clientToServerPipe.Reader.AsStream(), serverToClientPipe.Writer.AsStream()) + .WithTools() + .WithMcpApps(); + +await using var serviceProvider = services.BuildServiceProvider(); +var server = serviceProvider.GetRequiredService(); _ = server.RunAsync(); // Connect a client using a stream-based transport over the same in-memory pipe. @@ -20,13 +23,18 @@ // List all tools. var tools = await client.ListToolsAsync(); -if (tools.Count == 0) +var echo = tools.FirstOrDefault(t => t.Name == "Echo"); +if (echo is null) +{ + throw new Exception("Expected the Echo tool."); +} + +var ui = echo.ProtocolTool.Meta?["ui"]?.AsObject(); +if (ui?["resourceUri"]?.GetValue() != "ui://aot/echo") { - throw new Exception("Expected at least one tool."); + throw new Exception($"Unexpected app UI metadata: {ui}"); } -// Invoke a tool. -var echo = tools.First(t => t.Name == "Echo"); var result = await echo.InvokeAsync(new() { ["arg"] = "Hello World" }); if (result is null || !result.ToString()!.Contains("Echo: Hello World")) { @@ -34,3 +42,11 @@ } Console.WriteLine("Success!"); + +[McpServerToolType] +internal sealed class AotTools +{ + [McpServerTool(Name = "Echo")] + [McpAppUi(ResourceUri = "ui://aot/echo")] + public static string Echo(string arg) => $"Echo: {arg}"; +} diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/AddKnownToolsHeaderTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/AddKnownToolsHeaderTests.cs new file mode 100644 index 000000000..9e2040d1b --- /dev/null +++ b/tests/ModelContextProtocol.AspNetCore.Tests/AddKnownToolsHeaderTests.cs @@ -0,0 +1,436 @@ +using Microsoft.AspNetCore.Builder; +using Microsoft.AspNetCore.Http; +using Microsoft.AspNetCore.Http.Json; +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.AspNetCore.Tests.Utils; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Tests.Utils; +using System.Collections.Concurrent; +using System.Text.Json; + +namespace ModelContextProtocol.AspNetCore.Tests; + +/// +/// Tests that allows sending Mcp-Param-* headers +/// without a prior call. +/// +public class AddKnownToolsHeaderTests(ITestOutputHelper outputHelper) : KestrelInMemoryTest(outputHelper), IAsyncDisposable +{ + private WebApplication? _app; + + /// + /// Captured headers from tools/call requests, keyed by JSON-RPC request id. + /// + private readonly ConcurrentDictionary> _capturedHeaders = new(); + + private async Task StartAsync() + { + Builder.Services.Configure(options => + { + options.SerializerOptions.TypeInfoResolverChain.Add(McpJsonUtilities.DefaultOptions.TypeInfoResolver!); + }); + _app = Builder.Build(); + + _app.MapPost("/mcp", (JsonRpcMessage message, HttpContext context) => + { + if (message is not JsonRpcRequest request) + { + return Results.Accepted(); + } + + if (request.Method == "initialize") + { + return Results.Json(new JsonRpcResponse + { + Id = request.Id, + Result = JsonSerializer.SerializeToNode(new InitializeResult + { + ProtocolVersion = "2025-11-25", + Capabilities = new() { Tools = new() }, + ServerInfo = new Implementation { Name = "header-capture-test", Version = "1.0" }, + }, McpJsonUtilities.DefaultOptions) + }); + } + + if (request.Method == "tools/call") + { + // Capture all Mcp-Param-* headers from the incoming HTTP request + var paramHeaders = new Dictionary(StringComparer.OrdinalIgnoreCase); + foreach (var header in context.Request.Headers) + { + if (header.Key.StartsWith("Mcp-Param-", StringComparison.OrdinalIgnoreCase)) + { + paramHeaders[header.Key] = header.Value.ToString(); + } + } + + _capturedHeaders[request.Id.ToString()!] = paramHeaders; + + var parameters = JsonSerializer.Deserialize(request.Params, McpJsonUtilities.DefaultOptions.GetTypeInfo(typeof(CallToolRequestParams))) as CallToolRequestParams; + + return Results.Json(new JsonRpcResponse + { + Id = request.Id, + Result = JsonSerializer.SerializeToNode(new CallToolResult + { + Content = [new TextContentBlock { Text = $"ok" }], + }, McpJsonUtilities.DefaultOptions), + }); + } + + if (request.Method == "tools/list") + { + return Results.Json(new JsonRpcResponse + { + Id = request.Id, + Result = JsonSerializer.SerializeToNode(new ListToolsResult + { + Tools = [], + }, McpJsonUtilities.DefaultOptions), + }); + } + + return Results.Accepted(); + }); + + await _app.StartAsync(TestContext.Current.CancellationToken); + + HttpClient.DefaultRequestHeaders.Accept.Add(new("application/json")); + HttpClient.DefaultRequestHeaders.Accept.Add(new("text/event-stream")); + } + + public async ValueTask DisposeAsync() + { + if (_app is not null) + { + await _app.DisposeAsync(); + } + base.Dispose(); + } + + private static Tool CreateToolWithHeaders() + { + var schemaJson = """ + { + "type": "object", + "properties": { + "region": { + "type": "string", + "x-mcp-header": "Region" + }, + "priority": { + "type": "integer", + "x-mcp-header": "Priority" + } + }, + "required": ["region", "priority"] + } + """; + + return new Tool + { + Name = "my_tool", + InputSchema = JsonDocument.Parse(schemaJson).RootElement.Clone(), + }; + } + + [Fact] + public async Task AddKnownTools_ThenCallTool_SendsMcpParamHeaders_WithoutListToolsAsync() + { + await StartAsync(); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new("http://localhost:5000/mcp"), + TransportMode = HttpTransportMode.StreamableHttp, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions { ProtocolVersion = "2025-11-25" }, loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken); + + // Register the tool WITHOUT calling ListToolsAsync first — this is the core scenario from issue #1577 + client.AddKnownTools([CreateToolWithHeaders()]); + + // Call the tool + var result = await client.CallToolAsync( + "my_tool", + new Dictionary { ["region"] = "us-west-2", ["priority"] = 42 }, + cancellationToken: TestContext.Current.CancellationToken); + + Assert.NotNull(result); + + // Verify that Mcp-Param-* headers were captured by the server + Assert.Single(_capturedHeaders); + var headers = _capturedHeaders.Values.First(); + Assert.True(headers.ContainsKey("Mcp-Param-Region"), "Expected Mcp-Param-Region header to be sent"); + Assert.Equal("us-west-2", headers["Mcp-Param-Region"]); + Assert.True(headers.ContainsKey("Mcp-Param-Priority"), "Expected Mcp-Param-Priority header to be sent"); + Assert.Equal("42", headers["Mcp-Param-Priority"]); + } + + [Theory] + [InlineData("42.0", "42")] // decimal body form canonicalized + [InlineData("-7.00", "-7")] // trailing zeros canonicalized + [InlineData("-0.0", "0")] // negative zero canonicalized + [InlineData("4.2e1", "42")] // exponent body form canonicalized + [InlineData("9007199254740991", "9007199254740991")] // max safe integer preserved exactly + [InlineData("-9007199254740991", "-9007199254740991")] // min safe integer preserved exactly + public async Task CallTool_EmitsCanonicalIntegerHeader(string bodyValue, string expectedHeader) + { + await StartAsync(); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new("http://localhost:5000/mcp"), + TransportMode = HttpTransportMode.StreamableHttp, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions { ProtocolVersion = "2025-11-25" }, loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken); + + client.AddKnownTools([CreateToolWithHeaders()]); + + // Pass the raw JSON number so the body retains the exact form under test. + var result = await client.CallToolAsync( + "my_tool", + new Dictionary + { + ["region"] = "us-west-2", + ["priority"] = JsonDocument.Parse(bodyValue).RootElement, + }, + cancellationToken: TestContext.Current.CancellationToken); + + Assert.NotNull(result); + var headers = _capturedHeaders.Values.First(); + Assert.Equal(expectedHeader, headers["Mcp-Param-Priority"]); + } + + [Theory] + [InlineData("9007199254740993")] // 2^53 + 1, above the safe range + [InlineData("-9007199254740993")] // -(2^53 + 1), below the safe range + [InlineData("42.5")] // not a whole number + [InlineData("12e-1")] // 1.2 in exponent form, not a whole number + [InlineData("42.0000000000000000000000000001")] // high-precision fraction (decimal would round this to 42) + public async Task CallTool_ThrowsForInvalidIntegerHeaderValue(string bodyValue) + { + await StartAsync(); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new("http://localhost:5000/mcp"), + TransportMode = HttpTransportMode.StreamableHttp, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions { ProtocolVersion = "2025-11-25" }, loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken); + + client.AddKnownTools([CreateToolWithHeaders()]); + + // Values outside the JavaScript safe integer range (or non-integral) must be rejected + // before the request is sent. + await Assert.ThrowsAsync(async () => await client.CallToolAsync( + "my_tool", + new Dictionary + { + ["region"] = "us-west-2", + ["priority"] = JsonDocument.Parse(bodyValue).RootElement, + }, + cancellationToken: TestContext.Current.CancellationToken)); + + Assert.Empty(_capturedHeaders); + } + + [Fact] + public async Task CallToolWithoutRegisterOrList_DoesNotSendMcpParamHeaders() + { + await StartAsync(); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new("http://localhost:5000/mcp"), + TransportMode = HttpTransportMode.StreamableHttp, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions { ProtocolVersion = "2025-11-25" }, loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken); + + // Call the tool without AddKnownTools or ListToolsAsync — no Mcp-Param-* headers should be sent + var result = await client.CallToolAsync( + "my_tool", + new Dictionary { ["region"] = "us-west-2", ["priority"] = 42 }, + cancellationToken: TestContext.Current.CancellationToken); + + Assert.NotNull(result); + + // Verify that NO Mcp-Param-* headers were sent + Assert.Single(_capturedHeaders); + var headers = _capturedHeaders.Values.First(); + Assert.Empty(headers); + + // Verify that a cache miss warning IS logged for HTTP transport + Assert.Contains(MockLoggerProvider.LogMessages, log => + log.LogLevel == Microsoft.Extensions.Logging.LogLevel.Warning && + log.Message.Contains("not found in cache during tools/call")); + } + + [Fact] + public async Task AddKnownTools_SurvivesListToolsAsync_HeadersStillSent() + { + await StartAsync(); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new("http://localhost:5000/mcp"), + TransportMode = HttpTransportMode.StreamableHttp, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions { ProtocolVersion = "2025-11-25" }, loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken); + + // Register the tool first + client.AddKnownTools([CreateToolWithHeaders()]); + + // Call ListToolsAsync — server returns empty list, but registered tool should survive + await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + // Call the registered tool — Mcp-Param-* headers should still be sent + var result = await client.CallToolAsync( + "my_tool", + new Dictionary { ["region"] = "eu-central-1", ["priority"] = 99 }, + cancellationToken: TestContext.Current.CancellationToken); + + Assert.NotNull(result); + + // Verify headers were sent + Assert.Single(_capturedHeaders); + var headers = _capturedHeaders.Values.First(); + Assert.True(headers.ContainsKey("Mcp-Param-Region"), "Expected Mcp-Param-Region header after ListToolsAsync"); + Assert.Equal("eu-central-1", headers["Mcp-Param-Region"]); + Assert.True(headers.ContainsKey("Mcp-Param-Priority"), "Expected Mcp-Param-Priority header after ListToolsAsync"); + Assert.Equal("99", headers["Mcp-Param-Priority"]); + } + + [Fact] + public async Task RemoveKnownTools_ThenCallTool_NoMcpParamHeaders() + { + await StartAsync(); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new("http://localhost:5000/mcp"), + TransportMode = HttpTransportMode.StreamableHttp, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions { ProtocolVersion = "2025-11-25" }, loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken); + + // Register then remove — headers should no longer be sent + client.AddKnownTools([CreateToolWithHeaders()]); + client.RemoveKnownTools(["my_tool"]); + + var result = await client.CallToolAsync( + "my_tool", + new Dictionary { ["region"] = "us-east-1", ["priority"] = 1 }, + cancellationToken: TestContext.Current.CancellationToken); + + Assert.NotNull(result); + + // Verify no Mcp-Param-* headers were sent after removal + Assert.Single(_capturedHeaders); + var headers = _capturedHeaders.Values.First(); + Assert.Empty(headers); + } + + private static Tool CreateToolWithSingleHeader(string toolName, string headerName) + { + var schemaJson = $$""" + { + "type": "object", + "properties": { + "value": { + "type": "string", + "x-mcp-header": "{{headerName}}" + } + }, + "required": ["value"] + } + """; + + return new Tool + { + Name = toolName, + InputSchema = JsonDocument.Parse(schemaJson).RootElement.Clone(), + }; + } + + [Fact] + public async Task AddKnownTools_ServerReturnsEmptyList_RegisteredToolStillUsedForHeaders() + { + // Staleness test: register foo → server returns [] → ListToolsAsync → call foo → headers still sent + await StartAsync(); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new("http://localhost:5000/mcp"), + TransportMode = HttpTransportMode.StreamableHttp, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions { ProtocolVersion = "2025-11-25" }, loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken); + + // Register tool, then ListToolsAsync returns empty list from server + client.AddKnownTools([CreateToolWithHeaders()]); + await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + // Call the registered tool — headers should still be sent (sticky registration) + var result = await client.CallToolAsync( + "my_tool", + new Dictionary { ["region"] = "ap-southeast-1", ["priority"] = 5 }, + cancellationToken: TestContext.Current.CancellationToken); + + Assert.NotNull(result); + + Assert.Single(_capturedHeaders); + var headers = _capturedHeaders.Values.First(); + Assert.True(headers.ContainsKey("Mcp-Param-Region"), "Expected Mcp-Param-Region after server returned empty list"); + Assert.Equal("ap-southeast-1", headers["Mcp-Param-Region"]); + Assert.True(headers.ContainsKey("Mcp-Param-Priority"), "Expected Mcp-Param-Priority after server returned empty list"); + Assert.Equal("5", headers["Mcp-Param-Priority"]); + } + + [Fact] + public async Task AddKnownTools_ReRegisterOverwrite_LastWriteWinsHeaders() + { + // Last-write-wins: register foo with schema A → register foo with schema B → call → headers reflect schema B + await StartAsync(); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new("http://localhost:5000/mcp"), + TransportMode = HttpTransportMode.StreamableHttp, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions { ProtocolVersion = "2025-11-25" }, loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken); + + // Register with header "SchemaA", then overwrite with "SchemaB" + client.AddKnownTools([CreateToolWithSingleHeader("my_tool", "SchemaA")]); + client.AddKnownTools([CreateToolWithSingleHeader("my_tool", "SchemaB")]); + + var result = await client.CallToolAsync( + "my_tool", + new Dictionary { ["value"] = "test" }, + cancellationToken: TestContext.Current.CancellationToken); + + Assert.NotNull(result); + + Assert.Single(_capturedHeaders); + var headers = _capturedHeaders.Values.First(); + // SchemaA header should NOT be present + Assert.False(headers.ContainsKey("Mcp-Param-SchemaA"), "SchemaA header should have been overwritten"); + // SchemaB header SHOULD be present (last write wins) + Assert.True(headers.ContainsKey("Mcp-Param-SchemaB"), "Expected Mcp-Param-SchemaB from overwritten registration"); + Assert.Equal("test", headers["Mcp-Param-SchemaB"]); + } +} diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/AuthorizeAttributeTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/AuthorizeAttributeTests.cs index 76a7201d8..6ad643ef5 100644 --- a/tests/ModelContextProtocol.AspNetCore.Tests/AuthorizeAttributeTests.cs +++ b/tests/ModelContextProtocol.AspNetCore.Tests/AuthorizeAttributeTests.cs @@ -93,6 +93,91 @@ public async Task Authorize_Tool_AllowsAuthenticatedUser() Assert.Equal("Authorized: test", content.Text); } + [Fact] + public async Task Authorize_Tool_ReauthorizesPrimitiveChangedByInterveningFilter() + { + await using var app = await StartServerWithAuth(builder => + { + builder.WithTools(); + builder.Services.Configure(options => + { + if (options.ToolCollection is null || + !options.ToolCollection.TryGetPrimitive("authorized_tool", out var authorizedTool)) + { + throw new InvalidOperationException("The replacement tool was not registered."); + } + + options.Filters.Request.CallToolFilters.Add(next => async (context, cancellationToken) => + { + context.MatchedPrimitive = authorizedTool; + return await next(context, cancellationToken); + }); + }); + builder.AddAuthorizationFilters(); + }); + + var client = await ConnectAsync(); + + var exception = await Assert.ThrowsAsync(async () => + await client.CallToolAsync( + "anonymous_tool", + new Dictionary { ["message"] = "test" }, + cancellationToken: TestContext.Current.CancellationToken)); + + Assert.Equal("Request failed (remote): Access forbidden: This tool requires authorization.", exception.Message); + Assert.Equal(McpErrorCode.InvalidRequest, exception.ErrorCode); + } + + [Fact] + public async Task Authorize_Tool_ReauthorizesAfterEachInterveningFilter() + { + await using var app = await StartServerWithAuth(builder => + { + builder.WithTools(); + builder.Services.Configure(options => + { + if (options.ToolCollection is null || + !options.ToolCollection.TryGetPrimitive("authorized_tool", out var authorizedTool)) + { + throw new InvalidOperationException("The first replacement tool was not registered."); + } + + options.Filters.Request.CallToolFilters.Add(next => async (context, cancellationToken) => + { + context.MatchedPrimitive = authorizedTool; + return await next(context, cancellationToken); + }); + }); + builder.AddAuthorizationFilters(); + builder.Services.Configure(options => + { + if (options.ToolCollection is null || + !options.ToolCollection.TryGetPrimitive("admin_tool", out var adminTool)) + { + throw new InvalidOperationException("The second replacement tool was not registered."); + } + + options.Filters.Request.CallToolFilters.Add(next => async (context, cancellationToken) => + { + context.MatchedPrimitive = adminTool; + return await next(context, cancellationToken); + }); + }); + builder.AddAuthorizationFilters(); + }, "TestUser"); + + var client = await ConnectAsync(); + + var exception = await Assert.ThrowsAsync(async () => + await client.CallToolAsync( + "anonymous_tool", + new Dictionary { ["message"] = "test" }, + cancellationToken: TestContext.Current.CancellationToken)); + + Assert.Equal("Request failed (remote): Access forbidden: This tool requires authorization.", exception.Message); + Assert.Equal(McpErrorCode.InvalidRequest, exception.ErrorCode); + } + [Fact] public async Task AuthorizeWithRoles_Tool_RequiresAdminRole() { diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/CachingConformanceTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/CachingConformanceTests.cs new file mode 100644 index 000000000..f39f81761 --- /dev/null +++ b/tests/ModelContextProtocol.AspNetCore.Tests/CachingConformanceTests.cs @@ -0,0 +1,40 @@ +using ModelContextProtocol.Tests.Utils; + +namespace ModelContextProtocol.ConformanceTests; + +/// +/// Runs the official MCP conformance "caching" scenario (SEP-2549: TTL for List Results, +/// added in conformance PR #275) against the SDK's ConformanceServer, verifying that the SDK +/// correctly emits the ttlMs and cacheScope caching hints on cacheable results +/// (tools/list, prompts/list, resources/list, resources/templates/list, resources/read). +/// +/// +/// The scenario was introduced in spec wire version 2026-07-28 and uses the stateless lifecycle, +/// so it runs against the shared server's stateless endpoint +/// (). It is gated on the installed +/// conformance package's scenario list. +/// +[Collection(nameof(ConformanceServerCollection))] +public class CachingConformanceTests(ConformanceServerFixture fixture, ITestOutputHelper output) +{ + [Fact] + public async Task RunCachingConformanceTest() + { + Assert.SkipWhen(!NodeHelpers.IsNodeInstalled(), "Node.js is not installed. Skipping conformance tests."); + Assert.SkipWhen( + !NodeHelpers.HasCachingScenario(), + "SEP-2549 caching conformance scenario is not available in the installed conformance package."); + + // The caching scenario only exists in the 2026-07-28 protocol revision, so pin the spec version + // explicitly (and suppress the MCP_CONFORMANCE_PROTOCOL_VERSION override to avoid a + // conflicting duplicate --spec-version flag). + var result = await NodeHelpers.RunServerConformanceAsync( + $"server --url {fixture.StatelessServerUrl} --scenario caching --spec-version 2026-07-28", + line => { try { output.WriteLine(line); } catch { } }, + appendProtocolVersionFromEnv: false, + cancellationToken: TestContext.Current.CancellationToken); + + Assert.True(result.Success, + $"SEP-2549 caching conformance test failed.\n\nStdout:\n{result.Output}\n\nStderr:\n{result.Error}"); + } +} diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/ClientConformanceTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/ClientConformanceTests.cs index 72d075fe7..1b8be84c2 100644 --- a/tests/ModelContextProtocol.AspNetCore.Tests/ClientConformanceTests.cs +++ b/tests/ModelContextProtocol.AspNetCore.Tests/ClientConformanceTests.cs @@ -16,6 +16,9 @@ public class ClientConformanceTests // Public static property required for SkipUnless attribute public static bool IsNodeInstalled => NodeHelpers.IsNodeInstalled(); + public static bool HasSep2243Scenarios => NodeHelpers.HasSep2243Scenarios(); + public static bool HasRequestMetadataScenario => NodeHelpers.HasRequestMetadataScenario(); + public static bool HasConformantCustomHeadersScenario => NodeHelpers.HasConformantCustomHeadersScenario(); public ClientConformanceTests(ITestOutputHelper output) { @@ -43,13 +46,29 @@ public ClientConformanceTests(ITestOutputHelper output) [InlineData("auth/resource-mismatch")] [InlineData("auth/pre-registration")] - // Backcompat: Legacy 2025-03-26 OAuth flows (no PRM, root-location metadata). + // Offline access scope negotiation. + [InlineData("auth/offline-access-scope")] + [InlineData("auth/offline-access-not-supported")] + + // RFC 9207 authorization server issuer validation. + [InlineData("auth/iss-supported")] + [InlineData("auth/iss-not-advertised")] + [InlineData("auth/iss-supported-missing")] + [InlineData("auth/iss-wrong-issuer")] + [InlineData("auth/iss-unexpected")] + [InlineData("auth/iss-normalized")] + [InlineData("auth/metadata-issuer-mismatch")] + + // Backcompat: 2025-03-26 OAuth flows (no per-request metadata, root-location metadata). [InlineData("auth/2025-03-26-oauth-metadata-backcompat")] [InlineData("auth/2025-03-26-oauth-endpoint-fallback")] - // Extensions: Require ES256 JWT signing (private_key_jwt) and client_credentials grant support. - // [InlineData("auth/client-credentials-jwt")] - // [InlineData("auth/client-credentials-basic")] + [InlineData("auth/authorization-server-migration")] + [InlineData("auth/client-credentials-jwt")] + [InlineData("auth/client-credentials-basic")] + [InlineData("auth/enterprise-managed-authorization")] + [InlineData("sep-2322-client-request-state")] + [InlineData("json-schema-ref-no-deref")] public async Task RunConformanceTest(string scenario) { @@ -61,6 +80,47 @@ public async Task RunConformanceTest(string scenario) $"Conformance test failed.\n\nStdout:\n{result.Output}\n\nStderr:\n{result.Error}"); } + // Per-request metadata (SEP-2575) + [Fact(Skip = "SEP-2575 request-metadata conformance scenario is not available in the installed conformance package.", SkipUnless = nameof(HasRequestMetadataScenario))] + public async Task RunConformanceTest_RequestMetadata() + { + var result = await RunClientConformanceScenario("request-metadata"); + + Assert.True(result.Success, + $"Conformance test failed.\n\nStdout:\n{result.Output}\n\nStderr:\n{result.Error}"); + } + + // HTTP Standardization (SEP-2243) + [Theory(Skip = "SEP-2243 conformance scenarios are not available in the installed conformance package.", SkipUnless = nameof(HasSep2243Scenarios))] + [InlineData("http-standard-headers")] + [InlineData("http-invalid-tool-headers")] + public async Task RunConformanceTest_Sep2243(string scenario) + { + // Run the conformance test suite + var result = await RunClientConformanceScenario(scenario); + + // Report the results + Assert.True(result.Success, + $"Conformance test failed.\n\nStdout:\n{result.Output}\n\nStderr:\n{result.Error}"); + } + + // The http-custom-headers scenario needs a tighter gate than the other SEP-2243 scenarios: + // conformance 0.2.0-alpha.5 through 0.2.0-alpha.7 shipped it with an x-mcp-header on a + // number-typed parameter (forbidden by SEP-2243), which a conformant client excludes, + // failing every positive check. It was fixed upstream in 0.2.0-alpha.8 (conformance #371), + // so require at least that version to avoid spurious failures on older 0.2.0 prereleases. + [Theory(Skip = "Conformant http-custom-headers scenario not available (requires conformance package >= 0.2.0-alpha.8).", SkipUnless = nameof(HasConformantCustomHeadersScenario))] + [InlineData("http-custom-headers")] + public async Task RunConformanceTest_Sep2243_CustomHeaders(string scenario) + { + // Run the conformance test suite + var result = await RunClientConformanceScenario(scenario); + + // Report the results + Assert.True(result.Success, + $"Conformance test failed.\n\nStdout:\n{result.Output}\n\nStderr:\n{result.Error}"); + } + private async Task<(bool Success, string Output, string Error)> RunClientConformanceScenario(string scenario) { // Construct an absolute path to the conformance client executable diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/ConformanceServerFixture.cs b/tests/ModelContextProtocol.AspNetCore.Tests/ConformanceServerFixture.cs new file mode 100644 index 000000000..21fb98c2e --- /dev/null +++ b/tests/ModelContextProtocol.AspNetCore.Tests/ConformanceServerFixture.cs @@ -0,0 +1,104 @@ +using System.Diagnostics; +using ModelContextProtocol.Tests.Utils; + +namespace ModelContextProtocol.ConformanceTests; + +/// +/// Shared fixture that starts a single ConformanceServer exposing both the legacy stateful MCP +/// lifecycle (at , "/") and the SEP-2575 stateless lifecycle (at +/// , "/stateless") on one port. A single long-lived server avoids +/// the TCP TIME_WAIT conflicts that per-test restarts on a fixed port cause on Windows, and +/// centralizes the port-binding logic that the stateful and stateless conformance tests previously +/// duplicated. Shared by and +/// via . +/// +public sealed class ConformanceServerFixture : IAsyncLifetime +{ + // Use different ports for each target framework to allow parallel execution across the + // multi-targeted test processes. net10.0 -> 3001, net9.0 -> 3002, net8.0 -> 3003. + private static int GetPortForTargetFramework() + { + var testBinaryDir = AppContext.BaseDirectory; + var targetFramework = Path.GetFileName(testBinaryDir.TrimEnd(Path.DirectorySeparatorChar)); + + return targetFramework switch + { + "net10.0" => 3001, + "net9.0" => 3002, + "net8.0" => 3003, + _ => 3001 // Default fallback + }; + } + + private Task? _serverTask; + private CancellationTokenSource? _serverCts; + + /// Base URL of the stateful MCP endpoint (mapped at "/"). + public string ServerUrl { get; } = $"http://localhost:{GetPortForTargetFramework()}"; + + /// + /// URL of the stateless MCP endpoint (mapped at "/stateless"), used by the 2026-07-28 + /// scenarios (caching, MRTR, SEP-2243) that negotiate the stateless lifecycle. + /// + public string StatelessServerUrl => $"{ServerUrl}/stateless"; + + public async ValueTask InitializeAsync() + { + _serverCts = new CancellationTokenSource(); + _serverTask = Task.Run(() => ConformanceServer.Program.MainAsync( + ["--urls", ServerUrl], cancellationToken: _serverCts.Token)); + + // Wait for server to be ready (retry for up to 30 seconds) + var timeout = TimeSpan.FromSeconds(30); + var stopwatch = Stopwatch.StartNew(); + using var httpClient = new HttpClient { Timeout = TestConstants.HttpClientPollingTimeout }; + + while (stopwatch.Elapsed < timeout) + { + try + { + await httpClient.GetAsync($"{ServerUrl}/health"); + return; + } + catch (HttpRequestException) + { + // Connection refused means server not ready yet + } + catch (TaskCanceledException) + { + // Timeout means server might be processing, give it more time + } + + await Task.Delay(500); + } + + throw new InvalidOperationException("ConformanceServer failed to start within the timeout period"); + } + + public async ValueTask DisposeAsync() + { + if (_serverCts != null) + { + _serverCts.Cancel(); + if (_serverTask != null) + { + try + { + await _serverTask.WaitAsync(TestConstants.DefaultTimeout); + } + catch + { + // Ignore exceptions during shutdown + } + } + _serverCts.Dispose(); + } + } +} + +/// +/// xUnit collection that shares one across the conformance +/// test classes so they run against a single server instance (and a single bound port). +/// +[CollectionDefinition(nameof(ConformanceServerCollection))] +public sealed class ConformanceServerCollection : ICollectionFixture; diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/HttpHeaderConformanceTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/HttpHeaderConformanceTests.cs new file mode 100644 index 000000000..914b98db0 --- /dev/null +++ b/tests/ModelContextProtocol.AspNetCore.Tests/HttpHeaderConformanceTests.cs @@ -0,0 +1,654 @@ +using Microsoft.AspNetCore.Builder; +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.AspNetCore.Tests.Utils; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using ModelContextProtocol.Tests.Utils; +using System.Net; +using System.Net.ServerSentEvents; +using System.Text; +using System.Text.Json; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.AspNetCore.Tests; + +/// +/// Tests for SEP-2243 HTTP header standardization features: +/// - Custom Mcp-Param-* header validation +/// - Tab/control character encoding +/// - Numeric precision in header values +/// - Empty string header validation +/// - Invalid header character rejection +/// +public class HttpHeaderConformanceTests(ITestOutputHelper outputHelper) : KestrelInMemoryTest(outputHelper), IAsyncDisposable +{ + private WebApplication? _app; + + private async Task StartAsync() + { + Builder.Services.AddMcpServer(options => + { + options.ServerInfo = new Implementation + { + Name = nameof(HttpHeaderConformanceTests), + Version = "1.0", + }; +#pragma warning disable MCPEXP002 + options.RequestHandlers = + [ + new McpServerRequestHandler + { + Method = "extension/get", + RoutingNameParameter = "itemId", + Handler = static (_, _) => new ValueTask( + new JsonObject { ["resultType"] = "complete" }), + }, + ]; +#pragma warning restore MCPEXP002 + }).WithTools(Tools).WithHttpTransport(); + + _app = Builder.Build(); + _app.MapMcp(); + await _app.StartAsync(TestContext.Current.CancellationToken); + + HttpClient.DefaultRequestHeaders.Accept.Add(new("application/json")); + HttpClient.DefaultRequestHeaders.Accept.Add(new("text/event-stream")); + } + + public async ValueTask DisposeAsync() + { + if (_app is not null) + { + await _app.DisposeAsync(); + } + base.Dispose(); + } + + // Create a tool with x-mcp-header annotations in the schema. + // We set InputSchema directly because TransformSchemaNode doesn't provide + // property-level path context for lambda-based tool creation. + private static McpServerTool[] Tools { get; } = [CreateHeaderTestTool(), CreateUnionHeaderTestTool()]; + + private static readonly JsonSerializerOptions s_reflectionOptions = new() + { + TypeInfoResolver = new System.Text.Json.Serialization.Metadata.DefaultJsonTypeInfoResolver() + }; + + private static McpServerTool CreateHeaderTestTool() + { + var tool = McpServerTool.Create( + [McpServerTool(Name = "header_test")] + static (string region, long priority, bool verbose, string emptyVal) => + $"region={region},priority={priority},verbose={verbose},empty={emptyVal}", + new McpServerToolCreateOptions { SerializerOptions = s_reflectionOptions }); + + using var doc = JsonDocument.Parse(""" + { + "type": "object", + "properties": { + "region": { "type": "string", "x-mcp-header": "Region" }, + "priority": { "type": "integer", "x-mcp-header": "Priority" }, + "verbose": { "type": "boolean", "x-mcp-header": "Verbose" }, + "emptyVal": { "type": "string", "x-mcp-header": "EmptyVal" } + }, + "required": ["region", "priority", "verbose", "emptyVal"] + } + """); + tool.ProtocolTool.InputSchema = doc.RootElement.Clone(); + + return tool; + } + + // A tool whose integer header parameter uses a JSON Schema union type (["integer", "null"]). + private static McpServerTool CreateUnionHeaderTestTool() + { + var tool = McpServerTool.Create( + [McpServerTool(Name = "union_test")] + static (long priority) => $"priority={priority}", + new McpServerToolCreateOptions { SerializerOptions = s_reflectionOptions }); + + using var doc = JsonDocument.Parse(""" + { + "type": "object", + "properties": { + "priority": { "type": ["integer", "null"], "x-mcp-header": "Priority" } + }, + "required": ["priority"] + } + """); + tool.ProtocolTool.InputSchema = doc.RootElement.Clone(); + + return tool; + } + + #region Server-side validation tests + + [Fact] + public async Task Server_UsesCustomHandlerRoutingNameMetadata() + { + await StartAsync(); + await ProbeWithJuly2026ProtocolVersionAsync(); + + using var request = new HttpRequestMessage(HttpMethod.Post, ""); + request.Content = JsonContent( + """{"jsonrpc":"2.0","id":2,"method":"extension/get","params":{"itemId":"item-42","_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"TestClient","version":"1.0"},"io.modelcontextprotocol/clientCapabilities":{}}}}"""); + request.Headers.Add(McpHttpHeaders.ProtocolVersion, "2026-07-28"); + request.Headers.Add(McpHttpHeaders.Method, "extension/get"); + request.Headers.Add(McpHttpHeaders.Name, "item-42"); + + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + } + + [Fact] + public async Task Server_AcceptsUnionIntegerCanonicalForm() + { + await StartAsync(); + await ProbeWithJuly2026ProtocolVersionAsync(); + + // Union-typed (["integer","null"]) parameter: header carries canonical "42" while the body + // carries the decimal form 42.0. The server must treat the union type as integer and match. + var callJson = CallTool("union_test", """{"priority":42.0}"""); + + using var request = new HttpRequestMessage(HttpMethod.Post, ""); + request.Content = new StringContent(callJson, Encoding.UTF8, "application/json"); + request.Headers.Add("MCP-Protocol-Version", "2026-07-28"); + request.Headers.Add("Mcp-Method", "tools/call"); + request.Headers.Add("Mcp-Name", "union_test"); + request.Headers.Add("Mcp-Param-Priority", "42"); + + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + } + + [Fact] + public async Task Server_RejectsUnionIntegerOutsideSafeRange() + { + await StartAsync(); + await ProbeWithJuly2026ProtocolVersionAsync(); + + var callJson = CallTool("union_test", """{"priority":9007199254740993}"""); + + using var request = new HttpRequestMessage(HttpMethod.Post, ""); + request.Content = new StringContent(callJson, Encoding.UTF8, "application/json"); + request.Headers.Add("MCP-Protocol-Version", "2026-07-28"); + request.Headers.Add("Mcp-Method", "tools/call"); + request.Headers.Add("Mcp-Name", "union_test"); + request.Headers.Add("Mcp-Param-Priority", "9007199254740993"); + + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + } + + [Fact] + public async Task Server_AcceptsExponentBodyMatchingDecimalHeader() + { + await StartAsync(); + await ProbeWithJuly2026ProtocolVersionAsync(); + + // Body carries the integer in exponent form (1e2 = 100); header carries the decimal "100". + var callJson = CallTool("header_test", """{"region":"test","priority":1e2,"verbose":false,"emptyVal":""}"""); + + using var request = new HttpRequestMessage(HttpMethod.Post, ""); + request.Content = new StringContent(callJson, Encoding.UTF8, "application/json"); + request.Headers.Add("MCP-Protocol-Version", "2026-07-28"); + request.Headers.Add("Mcp-Method", "tools/call"); + request.Headers.Add("Mcp-Name", "header_test"); + request.Headers.Add("Mcp-Param-Region", "test"); + request.Headers.Add("Mcp-Param-Priority", "100"); + request.Headers.Add("Mcp-Param-Verbose", "false"); + request.Headers.Add("Mcp-Param-EmptyVal", ""); + + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + } + + [Fact] + public async Task Server_AcceptsWhitespaceAroundMcpNameHeaderValue() + { + await StartAsync(); + await ProbeWithJuly2026ProtocolVersionAsync(); + + // Per SEP-2243: servers MUST accept extra whitespace around header values + // and compare the trimmed value to the request body. + var callJson = CallTool("header_test", """{"region":"us-west1","priority":42,"verbose":false,"emptyVal":""}"""); + + using var request = new HttpRequestMessage(HttpMethod.Post, ""); + request.Content = new StringContent(callJson, Encoding.UTF8, "application/json"); + request.Headers.Add("MCP-Protocol-Version", "2026-07-28"); + request.Headers.TryAddWithoutValidation("Mcp-Method", "tools/call"); + request.Headers.TryAddWithoutValidation("Mcp-Name", " header_test "); + request.Headers.Add("Mcp-Param-Region", "us-west1"); + request.Headers.Add("Mcp-Param-Priority", "42"); + request.Headers.Add("Mcp-Param-Verbose", "false"); + request.Headers.Add("Mcp-Param-EmptyVal", ""); + + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + } + + [Fact] + public async Task Server_AcceptsWhitespaceAroundMcpMethodHeaderValue() + { + await StartAsync(); + await ProbeWithJuly2026ProtocolVersionAsync(); + + // Per SEP-2243: servers MUST accept extra whitespace around header values + var callJson = CallTool("header_test", """{"region":"us-west1","priority":42,"verbose":false,"emptyVal":""}"""); + + using var request = new HttpRequestMessage(HttpMethod.Post, ""); + request.Content = new StringContent(callJson, Encoding.UTF8, "application/json"); + request.Headers.Add("MCP-Protocol-Version", "2026-07-28"); + request.Headers.TryAddWithoutValidation("Mcp-Method", " tools/call "); + request.Headers.TryAddWithoutValidation("Mcp-Name", "header_test"); + request.Headers.Add("Mcp-Param-Region", "us-west1"); + request.Headers.Add("Mcp-Param-Priority", "42"); + request.Headers.Add("Mcp-Param-Verbose", "false"); + request.Headers.Add("Mcp-Param-EmptyVal", ""); + + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + } + + [Fact] + public async Task Server_ValidatesEmptyStringHeaderValue_AgainstBodyValue() + { + await StartAsync(); + await ProbeWithJuly2026ProtocolVersionAsync(); + + // Send a tools/call with an empty string param that has an x-mcp-header. + // The header should be present with an empty value, matching the body's empty string. + var callJson = CallTool("header_test", """{"region":"us-west1","priority":42,"verbose":false,"emptyVal":""}"""); + + using var request = new HttpRequestMessage(HttpMethod.Post, ""); + request.Content = new StringContent(callJson, Encoding.UTF8, "application/json"); + request.Headers.Add("MCP-Protocol-Version", "2026-07-28"); + request.Headers.Add("Mcp-Method", "tools/call"); + request.Headers.Add("Mcp-Name", "header_test"); + request.Headers.Add("Mcp-Param-Region", "us-west1"); + request.Headers.Add("Mcp-Param-Priority", "42"); + request.Headers.Add("Mcp-Param-Verbose", "false"); + request.Headers.Add("Mcp-Param-EmptyVal", ""); + + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + } + + [Fact] + public async Task Server_RejectsHeaderMismatch_WhenEmptyHeaderDoesNotMatchBody() + { + await StartAsync(); + await ProbeWithJuly2026ProtocolVersionAsync(); + + // Send a tools/call where the body has a non-empty value but the header is empty + var callJson = CallTool("header_test", """{"region":"us-west1","priority":42,"verbose":false,"emptyVal":"some-value"}"""); + + using var request = new HttpRequestMessage(HttpMethod.Post, ""); + request.Content = new StringContent(callJson, Encoding.UTF8, "application/json"); + request.Headers.Add("MCP-Protocol-Version", "2026-07-28"); + request.Headers.Add("Mcp-Method", "tools/call"); + request.Headers.Add("Mcp-Name", "header_test"); + request.Headers.Add("Mcp-Param-Region", "us-west1"); + request.Headers.Add("Mcp-Param-Priority", "42"); + request.Headers.Add("Mcp-Param-Verbose", "false"); + request.Headers.Add("Mcp-Param-EmptyVal", ""); + + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + } + + [Fact] + public async Task Server_AcceptsBase64EncodedHeaderWithControlChars() + { + await StartAsync(); + await ProbeWithJuly2026ProtocolVersionAsync(); + + // Encode a value with a newline control character using Base64 + var valueWithNewline = "line1\nline2"; + var encodedValue = McpHeaderEncoder.EncodeValue(valueWithNewline); + + var callJson = CallTool("header_test", $$"""{"region":"{{valueWithNewline.Replace("\n", "\\n")}}","priority":42,"verbose":false,"emptyVal":""}"""); + + using var request = new HttpRequestMessage(HttpMethod.Post, ""); + request.Content = new StringContent(callJson, Encoding.UTF8, "application/json"); + request.Headers.Add("MCP-Protocol-Version", "2026-07-28"); + request.Headers.Add("Mcp-Method", "tools/call"); + request.Headers.Add("Mcp-Name", "header_test"); + request.Headers.Add("Mcp-Param-Region", encodedValue!); + request.Headers.Add("Mcp-Param-Priority", "42"); + request.Headers.Add("Mcp-Param-Verbose", "false"); + request.Headers.Add("Mcp-Param-EmptyVal", ""); + + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + } + + [Fact] + public async Task Server_AcceptsMaxSafeIntegerWithFullPrecision() + { + await StartAsync(); + await ProbeWithJuly2026ProtocolVersionAsync(); + + // The maximum safe integer (2^53 - 1) must be accepted, and compared exactly without + // losing precision through a double conversion. + const long maxSafeInt = 9007199254740991L; + var callJson = CallTool("header_test", $$"""{"region":"test","priority":{{maxSafeInt}},"verbose":false,"emptyVal":""}"""); + + using var request = new HttpRequestMessage(HttpMethod.Post, ""); + request.Content = new StringContent(callJson, Encoding.UTF8, "application/json"); + request.Headers.Add("MCP-Protocol-Version", "2026-07-28"); + request.Headers.Add("Mcp-Method", "tools/call"); + request.Headers.Add("Mcp-Name", "header_test"); + request.Headers.Add("Mcp-Param-Region", "test"); + request.Headers.Add("Mcp-Param-Priority", maxSafeInt.ToString()); + request.Headers.Add("Mcp-Param-Verbose", "false"); + request.Headers.Add("Mcp-Param-EmptyVal", ""); + + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + } + + [Theory] + [InlineData("9007199254740993")] // 2^53 + 1, just outside the safe range + [InlineData("-9007199254740993")] // -(2^53 + 1), just outside the safe range + [InlineData("100000000000000000000000000000000000000")] // far beyond decimal range + [InlineData("1e100")] // exponent form far beyond the safe range + public async Task Server_RejectsIntegerOutsideSafeRange(string outOfRangeValue) + { + await StartAsync(); + await ProbeWithJuly2026ProtocolVersionAsync(); + + // Per SEP-2243 integer values MUST be within the JavaScript safe integer range. + // A matching header and body that are both outside the range must still be rejected. + var callJson = CallTool("header_test", $$"""{"region":"test","priority":{{outOfRangeValue}},"verbose":false,"emptyVal":""}"""); + + using var request = new HttpRequestMessage(HttpMethod.Post, ""); + request.Content = new StringContent(callJson, Encoding.UTF8, "application/json"); + request.Headers.Add("MCP-Protocol-Version", "2026-07-28"); + request.Headers.Add("Mcp-Method", "tools/call"); + request.Headers.Add("Mcp-Name", "header_test"); + request.Headers.Add("Mcp-Param-Region", "test"); + request.Headers.Add("Mcp-Param-Priority", outOfRangeValue); + request.Headers.Add("Mcp-Param-Verbose", "false"); + request.Headers.Add("Mcp-Param-EmptyVal", ""); + + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + } + + [Theory] + [InlineData("42", "42")] // "42" header vs 42 body -> exact integer match + [InlineData("42.0", "42")] // "42.0" header vs 42 body -> numeric equivalence + [InlineData("42", "42.0")] // "42" header vs 42.0 body (decimal form from another SDK) -> numeric equivalence + [InlineData("42", "4.2e1")] // "42" header vs 4.2e1 body (exponent form) -> numeric equivalence + [InlineData("420e-1", "42")] // "420e-1" header vs 42 body -> numeric equivalence + public async Task Server_AcceptsNumericEquivalentHeaderValues(string headerValue, string bodyValue) + { + await StartAsync(); + await ProbeWithJuly2026ProtocolVersionAsync(); + + // bodyValue is inserted as a raw JSON numeric literal so that forms such as "42.0" and + // "4.2e1" are preserved in the body exactly as another SDK might serialize them. + var callJson = CallTool("header_test", $$"""{"region":"test","priority":{{bodyValue}},"verbose":false,"emptyVal":""}"""); + + using var request = new HttpRequestMessage(HttpMethod.Post, ""); + request.Content = new StringContent(callJson, Encoding.UTF8, "application/json"); + request.Headers.Add("MCP-Protocol-Version", "2026-07-28"); + request.Headers.Add("Mcp-Method", "tools/call"); + request.Headers.Add("Mcp-Name", "header_test"); + request.Headers.Add("Mcp-Param-Region", "test"); + request.Headers.Add("Mcp-Param-Priority", headerValue); + request.Headers.Add("Mcp-Param-Verbose", "false"); + request.Headers.Add("Mcp-Param-EmptyVal", ""); + + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + } + + [Theory] + [InlineData("42.5")] // fractional value for an integer parameter + [InlineData("12e-1")] // 1.2 in exponent form + [InlineData("42.0000000000000000000000000001")] // high-precision fraction that decimal would round to 42 + public async Task Server_RejectsNonIntegerValue_EvenWhenHeaderAndBodyMatch(string nonIntegerValue) + { + await StartAsync(); + await ProbeWithJuly2026ProtocolVersionAsync(); + + // For an integer-typed parameter a non-whole numeric value is invalid and must be rejected + // even when the header and body strings are byte-for-byte identical (it must not slip through + // the ordinal comparison). + var callJson = CallTool("header_test", $$"""{"region":"test","priority":{{nonIntegerValue}},"verbose":false,"emptyVal":""}"""); + + using var request = new HttpRequestMessage(HttpMethod.Post, ""); + request.Content = new StringContent(callJson, Encoding.UTF8, "application/json"); + request.Headers.Add("MCP-Protocol-Version", "2026-07-28"); + request.Headers.Add("Mcp-Method", "tools/call"); + request.Headers.Add("Mcp-Name", "header_test"); + request.Headers.Add("Mcp-Param-Region", "test"); + request.Headers.Add("Mcp-Param-Priority", nonIntegerValue); + request.Headers.Add("Mcp-Param-Verbose", "false"); + request.Headers.Add("Mcp-Param-EmptyVal", ""); + + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + } + + [Fact] + public async Task Server_RejectsNonNumericMismatch_ForIntegerParam() + { + await StartAsync(); + await ProbeWithJuly2026ProtocolVersionAsync(); + + // Header says "99" but body says priority:42 — must reject even with numeric comparison + var callJson = CallTool("header_test", """{"region":"test","priority":42,"verbose":false,"emptyVal":""}"""); + + using var request = new HttpRequestMessage(HttpMethod.Post, ""); + request.Content = new StringContent(callJson, Encoding.UTF8, "application/json"); + request.Headers.Add("MCP-Protocol-Version", "2026-07-28"); + request.Headers.Add("Mcp-Method", "tools/call"); + request.Headers.Add("Mcp-Name", "header_test"); + request.Headers.Add("Mcp-Param-Region", "test"); + request.Headers.Add("Mcp-Param-Priority", "99"); + request.Headers.Add("Mcp-Param-Verbose", "false"); + request.Headers.Add("Mcp-Param-EmptyVal", ""); + + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + } + + [Fact] + public async Task Server_SkipsHeaderValidation_ForInitializeHandshakeVersion() + { + await StartAsync(); + await InitializeWithInitializeHandshakeVersionAsync(); + + // With the initialize-handshake version, Mcp-Param-* headers are NOT validated even if mismatched. + var callJson = CallTool("header_test", """{"region":"us-west1","priority":42,"verbose":false,"emptyVal":""}""", includePerRequestMetadata: false); + + using var request = new HttpRequestMessage(HttpMethod.Post, ""); + request.Content = new StringContent(callJson, Encoding.UTF8, "application/json"); + // Send the WRONG header value. This should still succeed because the version uses initialize. + request.Headers.Add("MCP-Protocol-Version", "2025-11-25"); + request.Headers.Add("Mcp-Method", "tools/call"); + request.Headers.Add("Mcp-Name", "header_test"); + request.Headers.Add("Mcp-Param-Region", "WRONG-VALUE"); + + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + } + + [Fact] + public async Task Server_RejectsInvalidUtf8EncodedHeaderValue() + { + await StartAsync(); + await ProbeWithJuly2026ProtocolVersionAsync(); + + // Create a separate HttpClient that sends raw UTF-8 bytes in Mcp-* headers + // instead of properly base64-encoding non-ASCII values. + var handler = new SocketsHttpHandler + { + ConnectCallback = SocketsHttpHandler.ConnectCallback, + RequestHeaderEncodingSelector = (headerName, _) => + headerName.StartsWith("Mcp-", StringComparison.OrdinalIgnoreCase) + ? Encoding.UTF8 + : null + }; + + using var utf8Client = new HttpClient(handler); + ConfigureHttpClient(utf8Client); + utf8Client.DefaultRequestHeaders.Accept.Add(new("application/json")); + utf8Client.DefaultRequestHeaders.Accept.Add(new("text/event-stream")); + + // Send a tools/call with raw UTF-8 non-ASCII in the Mcp-Name header. + // Kestrel reads header bytes as Latin-1, so the UTF-8 bytes for "café☕" + // will be garbled and won't match the body value, causing rejection. + var callJson = CallTool("café☕", """{"region":"us-west1","priority":42,"verbose":false,"emptyVal":""}"""); + + using var request = new HttpRequestMessage(HttpMethod.Post, ""); + request.Content = new StringContent(callJson, Encoding.UTF8, "application/json"); + request.Headers.Add("MCP-Protocol-Version", "2026-07-28"); + request.Headers.TryAddWithoutValidation("Mcp-Method", "tools/call"); + // Raw UTF-8 non-ASCII value in Mcp-Name — server must reject this + request.Headers.TryAddWithoutValidation("Mcp-Name", "café☕"); + request.Headers.TryAddWithoutValidation("Mcp-Param-Region", "us-west1"); + request.Headers.TryAddWithoutValidation("Mcp-Param-Priority", "42"); + request.Headers.TryAddWithoutValidation("Mcp-Param-Verbose", "false"); + request.Headers.TryAddWithoutValidation("Mcp-Param-EmptyVal", ""); + + using var response = await utf8Client.SendAsync(request, TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + } + + #endregion + + #region Client-side encoding tests (unit tests for McpHeaderEncoder) + + [Theory] + [InlineData("hello\tworld")] + [InlineData("col1\tcol2\tcol3")] + public void Client_TabInValue_IsBase64Encoded(string value) + { + var encoded = McpHeaderEncoder.EncodeValue(value); + Assert.NotNull(encoded); + Assert.StartsWith("=?base64?", encoded); + Assert.EndsWith("?=", encoded); + + // Verify round-trip + var decoded = McpHeaderEncoder.DecodeValue(encoded); + Assert.Equal(value, decoded); + } + + [Theory] + [InlineData("simple-text", false)] + [InlineData("with space", false)] + [InlineData("Hello, 世界", true)] + [InlineData("line1\nline2", true)] + [InlineData("\ttab-start", true)] + [InlineData("mid\ttab", true)] + [InlineData("control\x01char", true)] + public void Client_EncodeValue_Base64OnlyWhenNeeded(string value, bool expectBase64) + { + var encoded = McpHeaderEncoder.EncodeValue(value); + Assert.NotNull(encoded); + + if (expectBase64) + { + Assert.StartsWith("=?base64?", encoded); + } + else + { + Assert.DoesNotContain("=?base64?", encoded); + } + + // All values must round-trip + var decoded = McpHeaderEncoder.DecodeValue(encoded); + Assert.Equal(value, decoded); + } + + [Fact] + public void Client_EncodeValue_LargeInteger_PreservesFullPrecision() + { + // 2^53 + 1 cannot be represented exactly as a double + var encoded = McpHeaderEncoder.EncodeValue(9007199254740993L); + Assert.Equal("9007199254740993", encoded); + } + + [Fact] + public void Client_EncodeValue_Boolean_EncodesCorrectly() + { + Assert.Equal("true", McpHeaderEncoder.EncodeValue(true)); + Assert.Equal("false", McpHeaderEncoder.EncodeValue(false)); + } + + #endregion + + #region Version gating tests + + [Theory] + [InlineData("2026-07-28", true)] + [InlineData("2025-11-25", false)] + [InlineData("2025-06-18", false)] + [InlineData("2024-11-05", false)] + [InlineData(null, false)] + [InlineData("", false)] + public void RequiresStandardHeaders_CorrectlyGatesVersions(string? version, bool expected) + { + Assert.Equal(expected, McpProtocolVersions.RequiresStandardHeaders(version)); + } + + #endregion + + #region Helpers + + private async Task ProbeWithJuly2026ProtocolVersionAsync() + { + HttpClient.DefaultRequestHeaders.Remove("mcp-session-id"); + + using var request = new HttpRequestMessage(HttpMethod.Post, ""); + request.Content = JsonContent(DiscoverRequestJuly2026Protocol); + request.Headers.Add("MCP-Protocol-Version", "2026-07-28"); + request.Headers.Add("Mcp-Method", "server/discover"); + + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + + // Starting with the 2026-07-28 protocol revision, clients use server/discover and per-request + // metadata instead of initialize. + } + + private async Task InitializeWithInitializeHandshakeVersionAsync() + { + HttpClient.DefaultRequestHeaders.Remove("mcp-session-id"); + + using var response = await HttpClient.PostAsync("", JsonContent(InitializeRequest), TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + + // Server is stateless by default (SEP-2567), so initializing with an initialize-handshake protocol does not return + // a mcp-session-id header. Subsequent requests are independent, just like requests on the 2026-07-28 revision. + } + + private static StringContent JsonContent(string json) => new(json, Encoding.UTF8, "application/json"); + + private long _lastRequestId = 1; + + private string CallTool(string toolName, string arguments = "{}", bool includePerRequestMetadata = true) + { + var id = Interlocked.Increment(ref _lastRequestId); + var meta = includePerRequestMetadata + ? @",""_meta"":{""io.modelcontextprotocol/protocolVersion"":""2026-07-28"",""io.modelcontextprotocol/clientInfo"":{""name"":""TestClient"",""version"":""1.0""},""io.modelcontextprotocol/clientCapabilities"":{}}" + : ""; + + return "{\"jsonrpc\":\"2.0\",\"id\":" + id + ",\"method\":\"tools/call\",\"params\":{\"name\":\"" + + toolName + "\",\"arguments\":" + arguments + meta + "}}"; + } + + private static string InitializeRequest => """ + {"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-11-25","capabilities":{},"clientInfo":{"name":"TestClient","version":"1.0"}}} + """; + + private static string DiscoverRequestJuly2026Protocol => """ + {"jsonrpc":"2.0","id":1,"method":"server/discover","params":{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"TestClient","version":"1.0"},"io.modelcontextprotocol/clientCapabilities":{}}}} + """; + + #endregion +} diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/HttpMcpServerBuilderExtensionsTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/HttpMcpServerBuilderExtensionsTests.cs index cc6ff0b13..6f36d1421 100644 --- a/tests/ModelContextProtocol.AspNetCore.Tests/HttpMcpServerBuilderExtensionsTests.cs +++ b/tests/ModelContextProtocol.AspNetCore.Tests/HttpMcpServerBuilderExtensionsTests.cs @@ -2,6 +2,7 @@ using Microsoft.Extensions.Caching.Distributed; using Microsoft.Extensions.Caching.Memory; using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Hosting; using Microsoft.Extensions.Options; using ModelContextProtocol.AspNetCore.Tests.Utils; using ModelContextProtocol.Protocol; @@ -184,6 +185,55 @@ public void SessionMigrationHandler_RemainsNull_WhenNothingIsRegistered() Assert.Null(options.SessionMigrationHandler); } + [Fact] + public async Task IdleTrackingBackgroundService_DoesNotStartTimer_WhenStateless() + { + Builder.Services + .AddMcpServer() + .WithHttpTransport(options => options.Stateless = true); + + using var app = Builder.Build(); + + var idleTrackingService = GetIdleTrackingService(app.Services); + Assert.NotNull(idleTrackingService); + + await idleTrackingService.StartAsync(TestContext.Current.CancellationToken); + + // BackgroundService.ExecuteTask is only set when ExecuteAsync has been kicked off via base.StartAsync. + // In stateless mode we early-return, so ExecuteTask should remain null. + Assert.Null(idleTrackingService.ExecuteTask); + + await idleTrackingService.StopAsync(TestContext.Current.CancellationToken); + } + + [Fact] + public async Task IdleTrackingBackgroundService_StartsTimer_WhenStateful() + { + Builder.Services + .AddMcpServer() + .WithHttpTransport(options => options.Stateless = false); + + using var app = Builder.Build(); + + var idleTrackingService = GetIdleTrackingService(app.Services); + Assert.NotNull(idleTrackingService); + + await idleTrackingService.StartAsync(TestContext.Current.CancellationToken); + + // In stateful mode the timer loop must start, so ExecuteTask should be set. + Assert.NotNull(idleTrackingService.ExecuteTask); + + await idleTrackingService.StopAsync(TestContext.Current.CancellationToken); + } + + private static BackgroundService? GetIdleTrackingService(IServiceProvider services) + { + // IdleTrackingBackgroundService is internal, so look it up by type name from the registered IHostedService instances. + return services.GetServices() + .OfType() + .FirstOrDefault(s => s.GetType().Name == "IdleTrackingBackgroundService"); + } + private sealed class StubSessionMigrationHandler : ISessionMigrationHandler { public ValueTask AllowSessionMigrationAsync( diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/HttpServerIntegrationTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/HttpServerIntegrationTests.cs index 5f961fe32..abd3823f2 100644 --- a/tests/ModelContextProtocol.AspNetCore.Tests/HttpServerIntegrationTests.cs +++ b/tests/ModelContextProtocol.AspNetCore.Tests/HttpServerIntegrationTests.cs @@ -34,7 +34,9 @@ public async Task ConnectAndPing_Sse_TestServer() // Arrange // Act - await using var client = await GetClientAsync(); + // ping was removed in the 2026-07-28 protocol revision (SEP-2575), so pin to the latest stable + // protocol version to keep exercising the legacy ping RPC. On the 2026-07-28 protocol, liveness relies on the transport. + await using var client = await GetClientAsync(new McpClientOptions { ProtocolVersion = "2025-11-25" }); await client.PingAsync(cancellationToken: TestContext.Current.CancellationToken); // Assert @@ -47,7 +49,9 @@ public async Task Connect_TestServer_ShouldProvideServerFields() // Arrange // Act - await using var client = await GetClientAsync(); + // Stateful Streamable HTTP only provisions a session ID under the legacy handshake. Starting with the + // 2026-07-28 protocol revision, Streamable HTTP no longer supports sessions. Pin to the latest stable version to keep covering session-ID provisioning. + await using var client = await GetClientAsync(new McpClientOptions { ProtocolVersion = "2025-11-25" }); // Assert Assert.NotNull(client.ServerCapabilities); diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/HttpServerTransportOptionsTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/HttpServerTransportOptionsTests.cs new file mode 100644 index 000000000..ae5e19fe2 --- /dev/null +++ b/tests/ModelContextProtocol.AspNetCore.Tests/HttpServerTransportOptionsTests.cs @@ -0,0 +1,68 @@ +namespace ModelContextProtocol.AspNetCore.Tests; + +public class HttpServerTransportOptionsTests +{ + [Fact] + public void SessionMode_DefaultsToStateless() + { + var options = new HttpServerTransportOptions(); + + Assert.Equal(HttpServerSessionMode.Stateless, options.SessionMode); + Assert.True(options.Stateless); + } + + [Theory] + [InlineData(true, HttpServerSessionMode.Stateless)] + [InlineData(false, HttpServerSessionMode.Stateful)] + public void SettingStateless_SelectsEquivalentSessionMode(bool stateless, HttpServerSessionMode expected) + { + var options = new HttpServerTransportOptions { Stateless = stateless }; + + Assert.Equal(stateless, options.Stateless); + Assert.Equal(expected, options.SessionMode); + } + + [Theory] + [InlineData(HttpServerSessionMode.Stateless, true)] + [InlineData(HttpServerSessionMode.Stateful, false)] + public void ReadingStateless_ReflectsSessionMode(HttpServerSessionMode sessionMode, bool expected) + { + var options = new HttpServerTransportOptions { SessionMode = sessionMode }; + + Assert.Equal(expected, options.Stateless); + } + + [Fact] + public void ReadingStateless_ReturnsFalseForHybridMode() + { + var options = new HttpServerTransportOptions + { + SessionMode = HttpServerSessionMode.StatefulForInitializeClients, + }; + + Assert.False(options.Stateless); + Assert.Equal(HttpServerSessionMode.StatefulForInitializeClients, options.SessionMode); + } + + [Fact] + public void AssigningBothProperties_DoesNotThrow_AndLastAssignmentWins() + { + var options = new HttpServerTransportOptions(); + + options.Stateless = false; + Assert.False(options.Stateless); + Assert.Equal(HttpServerSessionMode.Stateful, options.SessionMode); + + options.SessionMode = HttpServerSessionMode.StatefulForInitializeClients; + Assert.False(options.Stateless); + Assert.Equal(HttpServerSessionMode.StatefulForInitializeClients, options.SessionMode); + + options.Stateless = true; + Assert.True(options.Stateless); + Assert.Equal(HttpServerSessionMode.Stateless, options.SessionMode); + + options.SessionMode = HttpServerSessionMode.Stateful; + Assert.False(options.Stateless); + Assert.Equal(HttpServerSessionMode.Stateful, options.SessionMode); + } +} diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/HttpTaskIntegrationTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/HttpTaskIntegrationTests.cs index 2b74fcd14..d64a55987 100644 --- a/tests/ModelContextProtocol.AspNetCore.Tests/HttpTaskIntegrationTests.cs +++ b/tests/ModelContextProtocol.AspNetCore.Tests/HttpTaskIntegrationTests.cs @@ -1,342 +1,243 @@ using Microsoft.AspNetCore.Builder; +using Microsoft.AspNetCore.Authorization; using Microsoft.Extensions.DependencyInjection; using ModelContextProtocol.AspNetCore.Tests.Utils; using ModelContextProtocol.Client; +using ModelContextProtocol.Extensions.Tasks; using ModelContextProtocol.Protocol; using ModelContextProtocol.Server; -using System.ComponentModel; -using System.Text.Json; +using Moq; +using System.Security.Claims; namespace ModelContextProtocol.AspNetCore.Tests; -/// -/// Integration tests for MCP Tasks feature over HTTP transports. -/// Tests task creation, polling, cancellation, and result retrieval. -/// -public class HttpTaskIntegrationTests(ITestOutputHelper outputHelper) : KestrelInMemoryTest(outputHelper) +public class HttpTaskIntegrationTests(ITestOutputHelper testOutputHelper) : KestrelInMemoryTest(testOutputHelper) { - private readonly HttpClientTransportOptions DefaultTransportOptions = new() - { - Endpoint = new("http://localhost:5000/"), - Name = "In-memory Streamable HTTP Client", - }; - - private Task ConnectMcpClientAsync( - HttpClient? httpClient = null, - HttpClientTransportOptions? transportOptions = null, - McpClientOptions? clientOptions = null) - => McpClient.CreateAsync( - new HttpClientTransport(transportOptions ?? DefaultTransportOptions, httpClient ?? HttpClient, LoggerFactory), - clientOptions, - LoggerFactory, - TestContext.Current.CancellationToken); - - private static IDictionary CreateArguments(string key, object? value) - { - return new Dictionary - { - [key] = JsonSerializer.SerializeToElement(value, McpJsonUtilities.DefaultOptions) - }; - } - [Fact] - public async Task CallToolAsTask_ReturnsTask_WhenServerSupportsTasksAsync() + public async Task WithTasks_CanCallToolOverHttp() { - // Arrange - var taskStore = new InMemoryMcpTaskStore(); - Builder.Services.AddMcpServer(options => - { - options.TaskStore = taskStore; - }) - .WithHttpTransport() - .WithTools(); + Builder.Services + .AddMcpServer() + .WithHttpTransport() + .WithTasks(new InMemoryMcpTaskStore { DefaultPollIntervalMs = 10 }) + .WithTools(); await using var app = Builder.Build(); app.MapMcp(); await app.StartAsync(TestContext.Current.CancellationToken); - await using var client = await ConnectMcpClientAsync(); + await using var transport = new HttpClientTransport( + new HttpClientTransportOptions { Endpoint = new("http://localhost:5000") }, + HttpClient, + LoggerFactory); + await using var client = await McpClient.CreateAsync( + transport, + loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken); - // Act - Call tool with task augmentation - var result = await client.CallToolAsync( - new CallToolRequestParams - { - Name = "long_running_operation", - Arguments = CreateArguments("durationMs", 100), - Task = new McpTaskMetadata() - }, - TestContext.Current.CancellationToken); - - // Assert - Response should indicate task was created - Assert.NotNull(result); - Assert.Null(result.IsError); + var result = await client.CallToolWithPollingAsync( + new CallToolRequestParams { Name = "test" }, + cancellationToken: TestContext.Current.CancellationToken); + + Assert.Equal("Hello World!", Assert.IsType(Assert.Single(result.Content)).Text); } [Fact] - public async Task GetTaskAsync_ReturnsTaskStatus_WhenTaskExistsAsync() + public async Task WithTasks_AfterOrdinaryFilter_RunsFilter() { - // Arrange - var taskStore = new InMemoryMcpTaskStore(); - Builder.Services.AddMcpServer(options => - { - options.TaskStore = taskStore; - }) - .WithHttpTransport() - .WithTools(); + var filterInvocationCount = 0; + Builder.Services + .AddMcpServer(options => + { + options.Filters.Request.CallToolFilters.Add(next => async (context, cancellationToken) => + { + Interlocked.Increment(ref filterInvocationCount); + return await next(context, cancellationToken); + }); + }) + .WithHttpTransport() + .WithTasks(new InMemoryMcpTaskStore { DefaultPollIntervalMs = 10 }) + .WithTools(); await using var app = Builder.Build(); app.MapMcp(); await app.StartAsync(TestContext.Current.CancellationToken); - await using var client = await ConnectMcpClientAsync(); - - // First create a task by calling a tool with task augmentation - _ = await client.CallToolAsync( - new CallToolRequestParams - { - Name = "long_running_operation", - Arguments = CreateArguments("durationMs", 500), - Task = new McpTaskMetadata() - }, - TestContext.Current.CancellationToken); - - // Get all tasks - var tasks = await client.ListTasksAsync(cancellationToken: TestContext.Current.CancellationToken); - Assert.NotEmpty(tasks); - - // Act - Get the task status - var task = await client.GetTaskAsync(tasks[0].TaskId, cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Assert.NotNull(task); - Assert.Equal(tasks[0].TaskId, task.TaskId); + await using var transport = new HttpClientTransport( + new HttpClientTransportOptions { Endpoint = new("http://localhost:5000") }, + HttpClient, + LoggerFactory); + await using var client = await McpClient.CreateAsync( + transport, + loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken); + + var result = await client.CallToolWithPollingAsync( + new CallToolRequestParams { Name = "test" }, + cancellationToken: TestContext.Current.CancellationToken); + + Assert.Equal("Hello World!", Assert.IsType(Assert.Single(result.Content)).Text); + Assert.Equal(1, filterInvocationCount); } - [Fact] - public async Task ListTasksAsync_ReturnsTasks_WhenTasksExistAsync() + [Theory] + [InlineData(false)] + [InlineData(true)] + public async Task WithTasks_AuthorizedTool_Completes(bool registerTasksBeforeAuthorization) { - // Arrange - var taskStore = new InMemoryMcpTaskStore(); - Builder.Services.AddMcpServer(options => - { - options.TaskStore = taskStore; - }) - .WithHttpTransport() - .WithTools(); - - await using var app = Builder.Build(); - app.MapMcp(); - await app.StartAsync(TestContext.Current.CancellationToken); + var serverBuilder = Builder.Services + .AddMcpServer() + .WithHttpTransport(); - await using var client = await ConnectMcpClientAsync(); - - // Create multiple tasks - for (int i = 0; i < 3; i++) + if (registerTasksBeforeAuthorization) { - await client.CallToolAsync( - new CallToolRequestParams - { - Name = "long_running_operation", - Arguments = CreateArguments("durationMs", 1000), - Task = new McpTaskMetadata() - }, - TestContext.Current.CancellationToken); + serverBuilder + .WithTasks(new InMemoryMcpTaskStore { DefaultPollIntervalMs = 10 }) + .AddAuthorizationFilters(); } - - // Act - var tasks = await client.ListTasksAsync(cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Assert.NotNull(tasks); - Assert.Equal(3, tasks.Count); - } - - [Fact] - public async Task CancelTaskAsync_CancelsTask_WhenTaskIsRunningAsync() - { - // Arrange - var taskStore = new InMemoryMcpTaskStore(); - Builder.Services.AddMcpServer(options => + else { - options.TaskStore = taskStore; - }) - .WithHttpTransport() - .WithTools(); - - await using var app = Builder.Build(); - app.MapMcp(); - await app.StartAsync(TestContext.Current.CancellationToken); - - await using var client = await ConnectMcpClientAsync(); - - // Create a long-running task - await client.CallToolAsync( - new CallToolRequestParams - { - Name = "long_running_operation", - Arguments = CreateArguments("durationMs", 10000), - Task = new McpTaskMetadata() - }, - TestContext.Current.CancellationToken); - - var tasks = await client.ListTasksAsync(cancellationToken: TestContext.Current.CancellationToken); - Assert.NotEmpty(tasks); - - // Act - Cancel the task - var cancelledTask = await client.CancelTaskAsync(tasks[0].TaskId, cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Assert.NotNull(cancelledTask); - Assert.Equal(McpTaskStatus.Cancelled, cancelledTask.Status); - } + serverBuilder + .AddAuthorizationFilters() + .WithTasks(new InMemoryMcpTaskStore { DefaultPollIntervalMs = 10 }); + } - [Fact] - public async Task GetTaskResultAsync_ReturnsResult_WhenTaskCompletesAsync() - { - // Arrange - var taskStore = new InMemoryMcpTaskStore(); - Builder.Services.AddMcpServer(options => - { - options.TaskStore = taskStore; - }) - .WithHttpTransport() - .WithTools(); + serverBuilder.WithTools(); + Builder.Services.AddAuthorization(); await using var app = Builder.Build(); + app.Use(next => async context => + { + context.User = new ClaimsPrincipal(new ClaimsIdentity( + [new Claim(ClaimTypes.NameIdentifier, "test-user")], + "TestAuthType")); + await next(context); + }); app.MapMcp(); await app.StartAsync(TestContext.Current.CancellationToken); - await using var client = await ConnectMcpClientAsync(); - - // Create a quick task - await client.CallToolAsync( - new CallToolRequestParams - { - Name = "long_running_operation", - Arguments = CreateArguments("durationMs", 50), - Task = new McpTaskMetadata() - }, - TestContext.Current.CancellationToken); - - var tasks = await client.ListTasksAsync(cancellationToken: TestContext.Current.CancellationToken); - Assert.NotEmpty(tasks); + await using var transport = new HttpClientTransport( + new HttpClientTransportOptions { Endpoint = new("http://localhost:5000") }, + HttpClient, + LoggerFactory); + await using var client = await McpClient.CreateAsync( + transport, + loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken); - // Wait a bit for the task to complete - await Task.Delay(200, TestContext.Current.CancellationToken); + var result = await client.CallToolWithPollingAsync( + new CallToolRequestParams { Name = "authorized-test" }, + cancellationToken: TestContext.Current.CancellationToken); - // Act - Get the task result - var result = await client.GetTaskResultAsync(tasks[0].TaskId, cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Assert.NotEqual(default, result); + Assert.Equal("Authorized", Assert.IsType(Assert.Single(result.Content)).Text); } - [Fact] - public async Task TasksIsolated_BetweenSessions_WhenMultipleClientsConnectAsync() + [Theory] + [InlineData(false)] + [InlineData(true)] + public async Task WithTasks_UnauthorizedTool_DoesNotCreateTask(bool registerTasksBeforeAuthorization) { - // Arrange - var taskStore = new InMemoryMcpTaskStore(); - Builder.Services.AddMcpServer(options => - { - options.TaskStore = taskStore; - }) - .WithHttpTransport() - .WithTools(); - - await using var app = Builder.Build(); - app.MapMcp(); - await app.StartAsync(TestContext.Current.CancellationToken); - - // Connect two separate clients - await using var client1 = await ConnectMcpClientAsync(); - await using var client2 = await ConnectMcpClientAsync(); - - // Client 1 creates a task - await client1.CallToolAsync( - new CallToolRequestParams - { - Name = "long_running_operation", - Arguments = CreateArguments("durationMs", 1000), - Task = new McpTaskMetadata() - }, - TestContext.Current.CancellationToken); - - // Act - Both clients list tasks - var client1Tasks = await client1.ListTasksAsync(cancellationToken: TestContext.Current.CancellationToken); - var client2Tasks = await client2.ListTasksAsync(cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Tasks should be isolated by session - Assert.Single(client1Tasks); - Assert.Empty(client2Tasks); - } + var taskStore = new Mock(MockBehavior.Strict); + var serverBuilder = Builder.Services + .AddMcpServer() + .WithHttpTransport(); - [Fact] - public async Task ServerCapabilities_IncludesTasks_WhenTaskStoreConfiguredAsync() - { - // Arrange - var taskStore = new InMemoryMcpTaskStore(); - Builder.Services.AddMcpServer(options => + if (registerTasksBeforeAuthorization) { - options.TaskStore = taskStore; - }) - .WithHttpTransport() - .WithTools(); + serverBuilder + .WithTasks(taskStore.Object) + .AddAuthorizationFilters(); + } + else + { + serverBuilder + .AddAuthorizationFilters() + .WithTasks(taskStore.Object); + } + + serverBuilder.WithTools(); + Builder.Services.AddAuthorization(); await using var app = Builder.Build(); app.MapMcp(); await app.StartAsync(TestContext.Current.CancellationToken); - // Act - await using var client = await ConnectMcpClientAsync(); - - // Assert - Assert.NotNull(client.ServerCapabilities?.Tasks); + await using var transport = new HttpClientTransport( + new HttpClientTransportOptions { Endpoint = new("http://localhost:5000") }, + HttpClient, + LoggerFactory); + await using var client = await McpClient.CreateAsync( + transport, + loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken); + + var exception = await Assert.ThrowsAsync(() => + client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "authorized-test" }, + TestContext.Current.CancellationToken).AsTask()); + + Assert.Equal(McpErrorCode.InvalidRequest, exception.ErrorCode); + taskStore.Verify( + store => store.CreateTaskAsync(It.IsAny()), + Times.Never); } [Fact] - public async Task ListTools_ShowsTaskSupport_WhenToolIsAsyncAsync() + public async Task WithTasks_ReauthorizesToolChangedByOrdinaryFilter() { - // Arrange - var taskStore = new InMemoryMcpTaskStore(); - Builder.Services.AddMcpServer(options => + var serverBuilder = Builder.Services + .AddMcpServer() + .WithHttpTransport() + .WithTasks(new InMemoryMcpTaskStore { DefaultPollIntervalMs = 10 }) + .WithTools() + .AddAuthorizationFilters(); + + serverBuilder.Services.Configure(options => { - options.TaskStore = taskStore; - }) - .WithHttpTransport() - .WithTools(); + if (options.ToolCollection is null || + !options.ToolCollection.TryGetPrimitive("authorized-test", out var authorizedTool)) + { + throw new InvalidOperationException("The replacement tool was not registered."); + } + + options.Filters.Request.CallToolFilters.Add(next => async (context, cancellationToken) => + { + context.MatchedPrimitive = authorizedTool; + return await next(context, cancellationToken); + }); + }); + serverBuilder.AddAuthorizationFilters(); + Builder.Services.AddAuthorization(); await using var app = Builder.Build(); app.MapMcp(); await app.StartAsync(TestContext.Current.CancellationToken); - await using var client = await ConnectMcpClientAsync(); - - // Act - var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); - - // Assert - var asyncTool = tools.FirstOrDefault(t => t.Name == "long_running_operation"); - Assert.NotNull(asyncTool); - Assert.NotNull(asyncTool.ProtocolTool.Execution); - Assert.Equal(ToolTaskSupport.Optional, asyncTool.ProtocolTool.Execution.TaskSupport); + await using var transport = new HttpClientTransport( + new HttpClientTransportOptions { Endpoint = new("http://localhost:5000") }, + HttpClient, + LoggerFactory); + await using var client = await McpClient.CreateAsync( + transport, + loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken); + + var exception = await Assert.ThrowsAsync(() => + client.CallToolWithPollingAsync( + new CallToolRequestParams { Name = "test" }, + cancellationToken: TestContext.Current.CancellationToken).AsTask()); + + Assert.Contains("Access forbidden: This tool requires authorization.", exception.Message); } [McpServerToolType] - public sealed class LongRunningTools + private sealed class TestTools { - [McpServerTool, Description("Simulates a long-running operation")] - public static async Task LongRunningOperation( - [Description("Duration of the operation in milliseconds")] int durationMs, - CancellationToken cancellationToken) - { - await Task.Delay(durationMs, cancellationToken); - return $"Operation completed after {durationMs}ms"; - } + [McpServerTool(Name = "test")] + public static string Test() => "Hello World!"; - [McpServerTool, Description("A synchronous tool that does not support tasks")] - public static string SyncTool([Description("Input message")] string message) - { - return $"Sync result: {message}"; - } + [McpServerTool(Name = "authorized-test")] + [Authorize] + public static string AuthorizedTest() => "Authorized"; } } diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/July2026ProtocolHttpFallbackTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/July2026ProtocolHttpFallbackTests.cs new file mode 100644 index 000000000..599bdd9a8 --- /dev/null +++ b/tests/ModelContextProtocol.AspNetCore.Tests/July2026ProtocolHttpFallbackTests.cs @@ -0,0 +1,432 @@ +using Microsoft.AspNetCore.Builder; +using Microsoft.AspNetCore.Http; +using Microsoft.AspNetCore.Http.Json; +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.AspNetCore.Tests.Utils; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Tests.Utils; +using System.Net; +using System.Text.Json; +using System.Text.Json.Nodes; +using System.Text.Json.Serialization.Metadata; + +namespace ModelContextProtocol.AspNetCore.Tests; + +/// +/// Regression tests for the fallback from a 2026-07-28 per-request-metadata probe to the initialize +/// handshake over Streamable HTTP. These +/// hand-craft minimal HTTP servers that mimic real-world peer behavior (e.g. Python's +/// simple-streamablehttp-stateless returns a JSON-RPC error envelope in a 400 body +/// on a 2026-07-28 probe; vanilla Go does the same on POST /) so the client's HTTP-fallback +/// logic can be exercised in isolation without the cross-SDK harness. +/// +/// +/// +/// Two latent bugs were discovered during cross-SDK testing and fixed by the SEP-2575 / SEP-2567 +/// branch: +/// +/// +/// +/// only surfaced the three error codes +/// introduced by the 2026-07-28 revision (-32022, -32021, -32020) as ; +/// any other JSON-RPC error code in a 400 body (e.g. -32600 from an initialize-handshake server +/// that doesn't understand the 2026-07-28 _meta envelope) threw +/// and bypassed the connect-time fallback logic. Per spec PR #2844, the fallback must trigger +/// on ANY non-SEP-2575 JSON-RPC error in a 400 body. +/// +/// +/// treated any non-2xx HTTP response as a +/// signal to abandon the Streamable HTTP transport and fall back to SSE. That masked +/// application-level errors (including the three SEP-2575/SEP-2567 codes) because the SSE GET would +/// either fail with "session id required" or succeed against a different endpoint and lose +/// the actual signal. +/// +/// +/// +public class July2026ProtocolHttpFallbackTests(ITestOutputHelper outputHelper) : KestrelInMemoryTest(outputHelper), IAsyncDisposable +{ + private WebApplication? _app; + + public async ValueTask DisposeAsync() + { + if (_app is not null) + { + await _app.DisposeAsync(); + } + base.Dispose(); + } + + private async Task StartServerAsync(RequestDelegate handler) + { + Builder.Services.Configure(options => + { + options.SerializerOptions.TypeInfoResolverChain.Add(McpJsonUtilities.DefaultOptions.TypeInfoResolver!); + }); + + _app = Builder.Build(); + _app.MapPost("/mcp", handler); + await _app.StartAsync(TestContext.Current.CancellationToken); + } + + private static JsonTypeInfo GetJsonTypeInfo() => (JsonTypeInfo)McpJsonUtilities.DefaultOptions.GetTypeInfo(typeof(T)); + + private static async Task WriteJsonRpcErrorAsync(HttpContext context, HttpStatusCode statusCode, int code, string message) + { + var rpcError = new JsonRpcError + { + Id = default, + Error = new JsonRpcErrorDetail { Code = code, Message = message }, + }; + + context.Response.StatusCode = (int)statusCode; + context.Response.ContentType = "application/json"; + await context.Response.WriteAsync(JsonSerializer.Serialize(rpcError, GetJsonTypeInfo()), context.RequestAborted); + } + + /// + /// Mimics Python's simple-streamablehttp-stateless on a 2026-07-28 probe: returns + /// 400 + JSON-RPC -32600 ("Bad Request: Unsupported protocol version") for the + /// initial server/discover, then performs a normal initialize handshake + /// when the client falls back. + /// + [Fact] + public async Task Client_AgainstInitializeHandshakeHttpServer_FallsBack_To_Initialize_When_400_Contains_JsonRpcError() + { + var ct = TestContext.Current.CancellationToken; + + await StartServerAsync(async context => + { + var message = await JsonSerializer.DeserializeAsync( + context.Request.Body, + GetJsonTypeInfo(), + ct); + + if (message is not JsonRpcRequest request) + { + context.Response.StatusCode = StatusCodes.Status202Accepted; + return; + } + + // 2026-07-28 probe: simulate an initialize-handshake server that rejects the unknown protocol version with + // a -32600 envelope (matches Python's wire shape verified in cross-SDK testing). + if (request.Method == RequestMethods.ServerDiscover) + { + await WriteJsonRpcErrorAsync(context, HttpStatusCode.BadRequest, code: -32600, message: "Bad Request: Unsupported protocol version: 2026-07-28"); + return; + } + + // Initialize handshake: respond with the highest version this server speaks. + if (request.Method == RequestMethods.Initialize) + { + var response = new JsonRpcResponse + { + Id = request.Id, + Result = JsonSerializer.SerializeToNode(new InitializeResult + { + ProtocolVersion = McpProtocolVersions.June2025ProtocolVersion, + Capabilities = new() { Tools = new() }, + ServerInfo = new Implementation { Name = "initialize-handshake", Version = "1.0" }, + }, McpJsonUtilities.DefaultOptions), + }; + + context.Response.ContentType = "application/json"; + await JsonSerializer.SerializeAsync(context.Response.Body, response, GetJsonTypeInfo(), ct); + return; + } + + if (request.Method == RequestMethods.ToolsList) + { + var response = new JsonRpcResponse + { + Id = request.Id, + Result = JsonSerializer.SerializeToNode(new ListToolsResult { Tools = [] }, McpJsonUtilities.DefaultOptions), + }; + + context.Response.ContentType = "application/json"; + await JsonSerializer.SerializeAsync(context.Response.Body, response, GetJsonTypeInfo(), ct); + return; + } + + context.Response.StatusCode = StatusCodes.Status202Accepted; + }); + + // Default AutoDetect transport — exercises BOTH fixes (AutoDetect adopting StreamableHttp + // on JSON-RPC-error 400, and SendMessageAsync surfacing -32600 as McpProtocolException). + await using var transport = new HttpClientTransport(new() + { + Endpoint = new("http://localhost:5000/mcp"), + }, HttpClient, LoggerFactory); + + // Default options prefer 2026-07-28 but allow automatic fallback to an initialize-handshake server. + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions(), + loggerFactory: LoggerFactory, cancellationToken: ct); + + Assert.Equal(McpProtocolVersions.June2025ProtocolVersion, client.NegotiatedProtocolVersion); + + // Sanity: subsequent traffic still works post-fallback. + var tools = await client.ListToolsAsync(cancellationToken: ct); + Assert.Empty(tools); + } + + /// + /// Mimics vanilla Go: returns 400 + JSON-RPC -32022 with + /// data.supported[] on a 2026-07-28 probe so the client retries + /// initialize with one of the advertised versions. + /// + [Fact] + public async Task Client_OnUnsupportedProtocolVersion_AdoptsStreamableHttp_NoSseFallback() + { + var ct = TestContext.Current.CancellationToken; + + await StartServerAsync(async context => + { + var message = await JsonSerializer.DeserializeAsync( + context.Request.Body, + GetJsonTypeInfo(), + ct); + + if (message is not JsonRpcRequest request) + { + context.Response.StatusCode = StatusCodes.Status202Accepted; + return; + } + + if (request.Method == RequestMethods.ServerDiscover) + { + // -32022 with the spec-shaped data: client should retry with one of supported[]. + // Use the typed payload type so the source-generated serializer can handle it. + var data = JsonSerializer.SerializeToNode(new UnsupportedProtocolVersionErrorData + { + Supported = new List { McpProtocolVersions.November2025ProtocolVersion }, + Requested = McpProtocolVersions.July2026ProtocolVersion, + }, GetJsonTypeInfo()); + + var rpcError = new JsonRpcError + { + Id = request.Id, + Error = new JsonRpcErrorDetail + { + Code = (int)McpErrorCode.UnsupportedProtocolVersion, + Message = "Unsupported protocol version", + Data = data, + }, + }; + + context.Response.StatusCode = StatusCodes.Status400BadRequest; + context.Response.ContentType = "application/json"; + await context.Response.WriteAsync(JsonSerializer.Serialize(rpcError, GetJsonTypeInfo()), ct); + return; + } + + if (request.Method == RequestMethods.Initialize) + { + var response = new JsonRpcResponse + { + Id = request.Id, + Result = JsonSerializer.SerializeToNode(new InitializeResult + { + ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion, + Capabilities = new() { Tools = new() }, + ServerInfo = new Implementation { Name = "go-shaped", Version = "1.0" }, + }, McpJsonUtilities.DefaultOptions), + }; + + context.Response.ContentType = "application/json"; + await JsonSerializer.SerializeAsync(context.Response.Body, response, GetJsonTypeInfo(), ct); + return; + } + + context.Response.StatusCode = StatusCodes.Status202Accepted; + }); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new("http://localhost:5000/mcp"), + }, HttpClient, LoggerFactory); + + // Default options prefer 2026-07-28 but allow automatic fallback to an initialize-handshake server. + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions(), + loggerFactory: LoggerFactory, cancellationToken: ct); + + Assert.Equal(McpProtocolVersions.November2025ProtocolVersion, client.NegotiatedProtocolVersion); + } + + /// + /// A 400 with a JSON-RPC -32020 HeaderMismatch envelope must be surfaced to the + /// caller (no initialize fallback). Falling back wouldn't fix a malformed envelope. + /// + [Fact] + public async Task Client_OnHeaderMismatch_400_Surfaces_McpProtocolException_NoFallback() + { + var ct = TestContext.Current.CancellationToken; + bool initializeReceived = false; + + await StartServerAsync(async context => + { + var message = await JsonSerializer.DeserializeAsync( + context.Request.Body, + GetJsonTypeInfo(), + ct); + + if (message is JsonRpcRequest { Method: RequestMethods.Initialize }) + { + initializeReceived = true; + } + + if (message is JsonRpcRequest { Method: RequestMethods.ServerDiscover }) + { + await WriteJsonRpcErrorAsync(context, HttpStatusCode.BadRequest, + code: (int)McpErrorCode.HeaderMismatch, + message: "Header mismatch: MCP-Protocol-Version did not match body _meta"); + return; + } + + context.Response.StatusCode = StatusCodes.Status202Accepted; + }); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new("http://localhost:5000/mcp"), + }, HttpClient, LoggerFactory); + + var exception = await Assert.ThrowsAsync(async () => + { + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions + { + ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion, + }, loggerFactory: LoggerFactory, cancellationToken: ct); + }); + + Assert.Equal(McpErrorCode.HeaderMismatch, exception.ErrorCode); + Assert.False(initializeReceived); + } + + [Fact] + public async Task Client_OnPerRequestMetadataResponseWithMcpSessionId_IgnoresSessionState() + { + var ct = TestContext.Current.CancellationToken; + string? toolsListSessionId = null; + + await StartServerAsync(async context => + { + var message = await JsonSerializer.DeserializeAsync( + context.Request.Body, + GetJsonTypeInfo(), + ct); + + if (message is JsonRpcRequest { Method: RequestMethods.ServerDiscover } request) + { + var response = new JsonRpcResponse + { + Id = request.Id, + Result = JsonSerializer.SerializeToNode(new DiscoverResult + { + SupportedVersions = [McpProtocolVersions.July2026ProtocolVersion], + Capabilities = new ServerCapabilities(), + Meta = new JsonObject + { + [MetaKeys.ServerInfo] = JsonSerializer.SerializeToNode(new Implementation { Name = "bad-per-request-metadata-server", Version = "1.0" }, McpJsonUtilities.DefaultOptions), + }, + TimeToLive = TimeSpan.Zero, + CacheScope = CacheScope.Private, + }, McpJsonUtilities.DefaultOptions), + }; + + context.Response.Headers[McpHttpHeaders.SessionId] = "unexpected-session"; + context.Response.ContentType = "application/json"; + await JsonSerializer.SerializeAsync(context.Response.Body, response, GetJsonTypeInfo(), ct); + return; + } + + if (message is JsonRpcRequest { Method: RequestMethods.ToolsList } toolsListRequest) + { + toolsListSessionId = context.Request.Headers[McpHttpHeaders.SessionId].ToString(); + + var response = new JsonRpcResponse + { + Id = toolsListRequest.Id, + Result = JsonSerializer.SerializeToNode(new ListToolsResult { Tools = [] }, McpJsonUtilities.DefaultOptions), + }; + + context.Response.ContentType = "application/json"; + await JsonSerializer.SerializeAsync(context.Response.Body, response, GetJsonTypeInfo(), ct); + return; + } + + context.Response.StatusCode = StatusCodes.Status202Accepted; + }); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new("http://localhost:5000/mcp"), + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions + { + ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion, + }, loggerFactory: LoggerFactory, cancellationToken: ct); + + await client.ListToolsAsync(cancellationToken: ct); + + Assert.Null(client.SessionId); + Assert.Equal("", toolsListSessionId); + } + + [Fact] + public async Task Client_WithKnownSessionId_DoesNotEchoIt_OnPerRequestMetadataRequest() + { + var ct = TestContext.Current.CancellationToken; + string? discoverSessionId = null; + + await StartServerAsync(async context => + { + var message = await JsonSerializer.DeserializeAsync( + context.Request.Body, + GetJsonTypeInfo(), + ct); + + if (message is JsonRpcRequest { Method: RequestMethods.ServerDiscover } request) + { + discoverSessionId = context.Request.Headers[McpHttpHeaders.SessionId].ToString(); + + var response = new JsonRpcResponse + { + Id = request.Id, + Result = JsonSerializer.SerializeToNode(new DiscoverResult + { + SupportedVersions = [McpProtocolVersions.July2026ProtocolVersion], + Capabilities = new ServerCapabilities(), + Meta = new JsonObject + { + [MetaKeys.ServerInfo] = JsonSerializer.SerializeToNode(new Implementation { Name = "per-request-metadata-server", Version = "1.0" }, McpJsonUtilities.DefaultOptions), + }, + TimeToLive = TimeSpan.Zero, + CacheScope = CacheScope.Private, + }, McpJsonUtilities.DefaultOptions), + }; + + context.Response.ContentType = "application/json"; + await JsonSerializer.SerializeAsync(context.Response.Body, response, GetJsonTypeInfo(), ct); + return; + } + + context.Response.StatusCode = StatusCodes.Status202Accepted; + }); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new("http://localhost:5000/mcp"), + TransportMode = HttpTransportMode.StreamableHttp, + KnownSessionId = "legacy-session", + OwnsSession = false, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions + { + ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion, + }, loggerFactory: LoggerFactory, cancellationToken: ct); + + Assert.Equal("", discoverSessionId); + } +} diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/July2026ProtocolHttpHandlerTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/July2026ProtocolHttpHandlerTests.cs new file mode 100644 index 000000000..365cf281d --- /dev/null +++ b/tests/ModelContextProtocol.AspNetCore.Tests/July2026ProtocolHttpHandlerTests.cs @@ -0,0 +1,207 @@ +using Microsoft.AspNetCore.Builder; +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.AspNetCore.Tests.Utils; +using ModelContextProtocol.Protocol; +using System.Net; +using System.Text; +using System.Text.Json; + +namespace ModelContextProtocol.AspNetCore.Tests; + +/// +/// HTTP-level tests for the 2026-07-28 protocol revision (SEP-2575 + SEP-2567): verify that the server +/// does not issue Mcp-Session-Id for those requests and returns structured +/// errors instead of plain 400s. +/// +public class July2026ProtocolHttpHandlerTests(ITestOutputHelper outputHelper) : KestrelInMemoryTest(outputHelper), IAsyncDisposable +{ + private WebApplication? _app; + + private async Task StartAsync(bool stateless = false) + { + Builder.Services.AddMcpServer(options => + { + options.ServerInfo = new Implementation { Name = nameof(July2026ProtocolHttpHandlerTests), Version = "1" }; + }).WithHttpTransport(options => + { + // SessionMode = HttpServerSessionMode.Stateful maps the GET/DELETE endpoints and opts the author into sessions. Starting with + // the 2026-07-28 protocol revision, Streamable HTTP no longer supports sessions, so such a request is + // refused on a session-enabled server. SessionMode = HttpServerSessionMode.Stateless (the default) serves them natively. + options.SessionMode = stateless ? HttpServerSessionMode.Stateless : HttpServerSessionMode.Stateful; + }); + + _app = Builder.Build(); + _app.MapMcp(); + await _app.StartAsync(TestContext.Current.CancellationToken); + + HttpClient.DefaultRequestHeaders.Accept.Add(new("application/json")); + HttpClient.DefaultRequestHeaders.Accept.Add(new("text/event-stream")); + } + + public async ValueTask DisposeAsync() + { + if (_app is not null) + { + await _app.DisposeAsync(); + } + base.Dispose(); + } + + [Fact] + public async Task Request_OnStatelessServer_Succeeds_WithoutMcpSessionIdHeader() + { + await StartAsync(stateless: true); + + HttpClient.DefaultRequestHeaders.Add("MCP-Protocol-Version", McpProtocolVersions.July2026ProtocolVersion); + HttpClient.DefaultRequestHeaders.Add("Mcp-Method", "server/discover"); + + // On a stateless server, server/discover succeeds without creating a session. + var content = new StringContent( + DiscoverRequestJuly2026Protocol, + Encoding.UTF8, "application/json"); + using var response = await HttpClient.PostAsync("", content, TestContext.Current.CancellationToken); + + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + Assert.False(response.Headers.Contains("Mcp-Session-Id"), "Responses on the 2026-07-28 revision must not include Mcp-Session-Id"); + } + + [Fact] + public async Task Request_OnStatefulServer_IsRefused_WithUnsupportedProtocolVersionError() + { + // Starting with the 2026-07-28 protocol revision, Streamable HTTP no longer supports sessions (SEP-2567), + // so the server cannot honor it when configured with sessions (SessionMode = HttpServerSessionMode.Stateful). The server refuses that + // version with UnsupportedProtocolVersion (excluding it from Supported) so a dual-path client falls back + // to the initialize handshake. + await StartAsync(stateless: false); + + HttpClient.DefaultRequestHeaders.Add("MCP-Protocol-Version", McpProtocolVersions.July2026ProtocolVersion); + HttpClient.DefaultRequestHeaders.Add("Mcp-Method", "server/discover"); + + var content = new StringContent( + DiscoverRequestJuly2026Protocol, + Encoding.UTF8, "application/json"); + using var response = await HttpClient.PostAsync("", content, TestContext.Current.CancellationToken); + + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + Assert.False(response.Headers.Contains("Mcp-Session-Id")); + + var body = await response.Content.ReadAsStringAsync(TestContext.Current.CancellationToken); + var rpcMessage = JsonSerializer.Deserialize(body, McpJsonUtilities.DefaultOptions); + var rpcError = Assert.IsType(rpcMessage); + Assert.Equal((int)McpErrorCode.UnsupportedProtocolVersion, rpcError.Error.Code); + + var dataElement = (JsonElement)rpcError.Error.Data!; + var errorData = dataElement.Deserialize(McpJsonUtilities.DefaultOptions); + Assert.NotNull(errorData); + Assert.Equal(McpProtocolVersions.July2026ProtocolVersion, errorData.Requested); + // The 2026-07-28 protocol version is excluded from Supported so the client downgrades to an initialize-capable version. + Assert.NotEmpty(errorData.Supported); + Assert.DoesNotContain(McpProtocolVersions.July2026ProtocolVersion, errorData.Supported); + } + + [Fact] + public async Task RequestWithUnsupportedProtocolVersion_Returns_UnsupportedProtocolVersionError() + { + await StartAsync(stateless: true); + + HttpClient.DefaultRequestHeaders.Add("MCP-Protocol-Version", "2099-12-31"); + HttpClient.DefaultRequestHeaders.Add("Mcp-Method", "server/discover"); + + var content = new StringContent( + DiscoverRequestJuly2026Protocol, + Encoding.UTF8, "application/json"); + using var response = await HttpClient.PostAsync("", content, TestContext.Current.CancellationToken); + + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + + var body = await response.Content.ReadAsStringAsync(TestContext.Current.CancellationToken); + var rpcMessage = JsonSerializer.Deserialize(body, McpJsonUtilities.DefaultOptions); + var rpcError = Assert.IsType(rpcMessage); + Assert.Equal((int)McpErrorCode.UnsupportedProtocolVersion, rpcError.Error.Code); + + // Validate the structured data payload (SEP-2575 §"Unsupported Protocol Versions"). + var dataElement = (JsonElement)rpcError.Error.Data!; + var errorData = dataElement.Deserialize(McpJsonUtilities.DefaultOptions); + Assert.NotNull(errorData); + Assert.Equal("2099-12-31", errorData.Requested); + Assert.NotEmpty(errorData.Supported); + } + + [Fact] + public async Task Request_WithMcpSessionIdHeader_IgnoresHeader_AndDoesNotEchoSessionId() + { + // Starting with the 2026-07-28 protocol revision, Streamable HTTP no longer supports sessions (SEP-2567): + // a request carrying an Mcp-Session-Id is ignored, and the server must not mint or echo session IDs. + await StartAsync(stateless: true); + + HttpClient.DefaultRequestHeaders.Add("MCP-Protocol-Version", McpProtocolVersions.July2026ProtocolVersion); + HttpClient.DefaultRequestHeaders.Add("Mcp-Method", "server/discover"); + HttpClient.DefaultRequestHeaders.Add("Mcp-Session-Id", "non-existent-session-id"); + + var content = new StringContent( + DiscoverRequestJuly2026Protocol, + Encoding.UTF8, "application/json"); + using var response = await HttpClient.PostAsync("", content, TestContext.Current.CancellationToken); + + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + Assert.False(response.Headers.Contains("Mcp-Session-Id")); + } + + [Fact] + public async Task Get_WithoutSessionId_IsRejected() + { + await StartAsync(); + + HttpClient.DefaultRequestHeaders.Add("MCP-Protocol-Version", McpProtocolVersions.July2026ProtocolVersion); + + using var response = await HttpClient.GetAsync("", TestContext.Current.CancellationToken); + + Assert.Equal(HttpStatusCode.MethodNotAllowed, response.StatusCode); + Assert.Equal(["POST"], response.Content.Headers.Allow); + } + + [Fact] + public async Task Get_WithSessionId_IsRejected() + { + await StartAsync(); + + HttpClient.DefaultRequestHeaders.Add("MCP-Protocol-Version", McpProtocolVersions.July2026ProtocolVersion); + HttpClient.DefaultRequestHeaders.Add("Mcp-Session-Id", "non-existent-session-id"); + + using var response = await HttpClient.GetAsync("", TestContext.Current.CancellationToken); + + Assert.Equal(HttpStatusCode.MethodNotAllowed, response.StatusCode); + Assert.Equal(["POST"], response.Content.Headers.Allow); + } + + [Fact] + public async Task Delete_WithoutSessionId_IsRejected() + { + await StartAsync(); + + HttpClient.DefaultRequestHeaders.Add("MCP-Protocol-Version", McpProtocolVersions.July2026ProtocolVersion); + + using var response = await HttpClient.DeleteAsync("", TestContext.Current.CancellationToken); + + Assert.Equal(HttpStatusCode.MethodNotAllowed, response.StatusCode); + Assert.Equal(["POST"], response.Content.Headers.Allow); + } + + [Fact] + public async Task Delete_WithSessionId_IsRejected() + { + await StartAsync(); + + HttpClient.DefaultRequestHeaders.Add("MCP-Protocol-Version", McpProtocolVersions.July2026ProtocolVersion); + HttpClient.DefaultRequestHeaders.Add("Mcp-Session-Id", "non-existent-session-id"); + + using var response = await HttpClient.DeleteAsync("", TestContext.Current.CancellationToken); + + Assert.Equal(HttpStatusCode.MethodNotAllowed, response.StatusCode); + Assert.Equal(["POST"], response.Content.Headers.Allow); + } + + private static string DiscoverRequestJuly2026Protocol => """ + {"jsonrpc":"2.0","id":1,"method":"server/discover","params":{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"July2026HttpHandlerTestClient","version":"1.0"},"io.modelcontextprotocol/clientCapabilities":{}}}} + """; +} diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/July2026ProtocolHybridSessionModeTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/July2026ProtocolHybridSessionModeTests.cs new file mode 100644 index 000000000..01a4b26cf --- /dev/null +++ b/tests/ModelContextProtocol.AspNetCore.Tests/July2026ProtocolHybridSessionModeTests.cs @@ -0,0 +1,344 @@ +using Microsoft.AspNetCore.Builder; +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.AspNetCore.Tests.Utils; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.Net; +using System.Net.Http.Headers; +using System.Text; +using System.Text.Json; + +namespace ModelContextProtocol.AspNetCore.Tests; + +/// +/// End-to-end coverage for : a single endpoint +/// that serves initialize-handshake clients with full stateful sessions while serving 2026-07-28 +/// and later clients statelessly, without forcing them to downgrade +/// (). +/// +[McpServerToolType] +public class July2026ProtocolHybridSessionModeTests(ITestOutputHelper outputHelper) : KestrelInMemoryTest(outputHelper), IAsyncDisposable +{ + private WebApplication? _app; + private int _configureSessionOptionsCount; + private int _runSessionHandlerCount; + + public async ValueTask DisposeAsync() + { + if (_app is not null) + { + await _app.DisposeAsync(); + } + base.Dispose(); + } + + [McpServerTool(Name = "greet")] + public static string Greet([System.ComponentModel.Description("Name to greet")] string name) => $"Hello, {name}!"; + + [McpServerTool(Name = "greet_via_elicit")] + public static async Task GreetViaElicit(McpServer server, CancellationToken cancellationToken) + { + // Server to client requests only work over a stateful session, so this proves the initialize-handshake + // half of a hybrid endpoint keeps its session even though the endpoint also serves stateless requests. + var elicitResult = await server.ElicitAsync(new ElicitRequestParams + { + Message = "What is your name?", + RequestedSchema = new(), + }, cancellationToken); + + var name = elicitResult.Content?.TryGetValue("answer", out var answer) == true + ? answer.GetString() + : "stranger"; + + return $"Hello, {name}!"; + } + + [McpServerTool(Name = "scope_state")] + public static string ScopeState(ScopedService scopedService) => scopedService.State ?? ""; + + private async Task StartHybridServerAsync(bool trackRunSessionHandler = false) + { + Builder.Services.AddMcpServer(options => + { + options.ServerInfo = new Implementation { Name = nameof(July2026ProtocolHybridSessionModeTests), Version = "1" }; + }) + .WithHttpTransport(options => + { + options.SessionMode = HttpServerSessionMode.StatefulForInitializeClients; + options.ConfigureSessionOptions = (httpContext, mcpServerOptions, cancellationToken) => + { + Interlocked.Increment(ref _configureSessionOptionsCount); + return Task.CompletedTask; + }; + + if (trackRunSessionHandler) + { +#pragma warning disable MCPEXP002 // RunSessionHandler is experimental. + options.RunSessionHandler = async (httpContext, server, cancellationToken) => + { + Interlocked.Increment(ref _runSessionHandlerCount); + await server.RunAsync(cancellationToken); + }; +#pragma warning restore MCPEXP002 + } + }) + .WithTools(); + + Builder.Services.AddScoped(); + + _app = Builder.Build(); + + _app.Use(next => context => + { + context.RequestServices.GetRequiredService().State = "From request middleware!"; + return next(context); + }); + + _app.MapMcp(); + await _app.StartAsync(TestContext.Current.CancellationToken); + } + + private Task ConnectClientAsync(string? protocolVersion = null, Action? configureClient = null) + { + var transport = new HttpClientTransport(new HttpClientTransportOptions + { + Endpoint = new Uri("http://localhost:5000/"), + TransportMode = HttpTransportMode.StreamableHttp, + }, HttpClient, LoggerFactory); + + // A null ProtocolVersion prefers 2026-07-28 and probes with server/discover before considering a + // fallback to the initialize handshake. Pinning an older version forces the initialize handshake. + var clientOptions = new McpClientOptions { ProtocolVersion = protocolVersion }; + configureClient?.Invoke(clientOptions); + return McpClient.CreateAsync(transport, clientOptions, LoggerFactory, TestContext.Current.CancellationToken); + } + + [Fact] + public async Task ModernAndLegacyClients_ShareOneEndpoint_AndModernDoesNotDowngrade() + { + await StartHybridServerAsync(); + + await using var modernClient = await ConnectClientAsync(); + await using var legacyClient = await ConnectClientAsync(McpProtocolVersions.November2025ProtocolVersion); + + // The whole point of the hybrid mode: the default client keeps 2026-07-28 instead of downgrading. + Assert.Equal(McpProtocolVersions.July2026ProtocolVersion, modernClient.NegotiatedProtocolVersion); + Assert.Null(modernClient.SessionId); + + Assert.Equal(McpProtocolVersions.November2025ProtocolVersion, legacyClient.NegotiatedProtocolVersion); + Assert.False(string.IsNullOrEmpty(legacyClient.SessionId)); + + // Both halves of the endpoint remain usable while the other is connected. + var modernResult = await modernClient.CallToolAsync("greet", + new Dictionary { ["name"] = "Modern" }, + cancellationToken: TestContext.Current.CancellationToken); + Assert.Equal("Hello, Modern!", Assert.IsType(Assert.Single(modernResult.Content)).Text); + + var legacyResult = await legacyClient.CallToolAsync("greet", + new Dictionary { ["name"] = "Legacy" }, + cancellationToken: TestContext.Current.CancellationToken); + Assert.Equal("Hello, Legacy!", Assert.IsType(Assert.Single(legacyResult.Content)).Text); + } + + [Fact] + public async Task LegacyClient_OnHybridServer_StillSupportsServerToClientElicitation() + { + await StartHybridServerAsync(); + + await using var legacyClient = await ConnectClientAsync(McpProtocolVersions.November2025ProtocolVersion, options => + { + options.Handlers.ElicitationHandler = (request, ct) => new ValueTask(new ElicitResult + { + Action = "accept", + Content = new Dictionary + { + ["answer"] = JsonDocument.Parse("\"Bob\"").RootElement.Clone(), + }, + }); + }); + + var result = await legacyClient.CallToolAsync("greet_via_elicit", + cancellationToken: TestContext.Current.CancellationToken); + + Assert.True(result.IsError is not true); + Assert.Equal("Hello, Bob!", Assert.IsType(Assert.Single(result.Content)).Text); + } + + [Fact] + public async Task ModernRequests_UseRequestScopedServices_WhileLegacySessionsUseApplicationServices() + { + await StartHybridServerAsync(); + + await using var modernClient = await ConnectClientAsync(); + await using var legacyClient = await ConnectClientAsync(McpProtocolVersions.November2025ProtocolVersion); + + // Stateless requests resolve services from HttpContext.RequestServices, so the tool observes the state + // that the ASP.NET Core middleware set on the request-scoped service. + var modernResult = await modernClient.CallToolAsync("scope_state", cancellationToken: TestContext.Current.CancellationToken); + Assert.Equal("From request middleware!", Assert.IsType(Assert.Single(modernResult.Content)).Text); + + // Stateful sessions outlive the HTTP request, so they scope requests off the application services + // instead and never see the middleware's request-scoped state. + var legacyResult = await legacyClient.CallToolAsync("scope_state", cancellationToken: TestContext.Current.CancellationToken); + Assert.Equal("", Assert.IsType(Assert.Single(legacyResult.Content)).Text); + } + + [Fact] + public async Task ConfigureSessionOptions_RunsPerRequestForModernClients_AndOncePerSessionForLegacyClients() + { + await StartHybridServerAsync(); + + var beforeLegacyConnect = Volatile.Read(ref _configureSessionOptionsCount); + await using var legacyClient = await ConnectClientAsync(McpProtocolVersions.November2025ProtocolVersion); + + // The initialize request creates the session; notifications/initialized reuses it. + Assert.Equal(1, Volatile.Read(ref _configureSessionOptionsCount) - beforeLegacyConnect); + + var beforeLegacyCalls = Volatile.Read(ref _configureSessionOptionsCount); + await legacyClient.CallToolAsync("greet", new Dictionary { ["name"] = "Legacy" }, cancellationToken: TestContext.Current.CancellationToken); + await legacyClient.CallToolAsync("greet", new Dictionary { ["name"] = "Legacy" }, cancellationToken: TestContext.Current.CancellationToken); + + // Subsequent requests reuse the session, so the callback does not run again. + Assert.Equal(0, Volatile.Read(ref _configureSessionOptionsCount) - beforeLegacyCalls); + + await using var modernClient = await ConnectClientAsync(); + + var beforeModernCall = Volatile.Read(ref _configureSessionOptionsCount); + await modernClient.CallToolAsync("greet", new Dictionary { ["name"] = "Modern" }, cancellationToken: TestContext.Current.CancellationToken); + + // Each 2026-07-28 POST creates a fresh per-request server, so the callback runs again. + Assert.Equal(1, Volatile.Read(ref _configureSessionOptionsCount) - beforeModernCall); + } + + [Fact] + public async Task RunSessionHandler_RunsPerRequestForModernClients_AndOncePerSessionForLegacyClients() + { + await StartHybridServerAsync(trackRunSessionHandler: true); + + var beforeLegacyConnect = Volatile.Read(ref _runSessionHandlerCount); + await using var legacyClient = await ConnectClientAsync(McpProtocolVersions.November2025ProtocolVersion); + Assert.Equal(1, Volatile.Read(ref _runSessionHandlerCount) - beforeLegacyConnect); + + var beforeLegacyCalls = Volatile.Read(ref _runSessionHandlerCount); + await legacyClient.CallToolAsync("greet", new Dictionary { ["name"] = "Legacy" }, cancellationToken: TestContext.Current.CancellationToken); + await legacyClient.CallToolAsync("greet", new Dictionary { ["name"] = "Legacy" }, cancellationToken: TestContext.Current.CancellationToken); + Assert.Equal(0, Volatile.Read(ref _runSessionHandlerCount) - beforeLegacyCalls); + + var beforeModernConnect = Volatile.Read(ref _runSessionHandlerCount); + await using var modernClient = await ConnectClientAsync(); + Assert.Equal(1, Volatile.Read(ref _runSessionHandlerCount) - beforeModernConnect); + + var beforeModernCall = Volatile.Read(ref _runSessionHandlerCount); + await modernClient.CallToolAsync("greet", new Dictionary { ["name"] = "Modern" }, cancellationToken: TestContext.Current.CancellationToken); + Assert.Equal(1, Volatile.Read(ref _runSessionHandlerCount) - beforeModernCall); + } + + [Fact] + public async Task ModernPost_DoesNotMintSessionId_WhileLegacyInitializeDoes() + { + await StartHybridServerAsync(); + + using var modernResponse = await SendAsync(HttpMethod.Post, McpProtocolVersions.July2026ProtocolVersion, DiscoverRequest, mcpMethod: "server/discover"); + Assert.Equal(HttpStatusCode.OK, modernResponse.StatusCode); + Assert.False(modernResponse.Headers.Contains("Mcp-Session-Id"), "2026-07-28 responses must not include Mcp-Session-Id."); + + using var legacyResponse = await SendAsync(HttpMethod.Post, protocolVersion: null, InitializeRequest); + Assert.Equal(HttpStatusCode.OK, legacyResponse.StatusCode); + Assert.False(string.IsNullOrEmpty(Assert.Single(legacyResponse.Headers.GetValues("Mcp-Session-Id")))); + } + + [Fact] + public async Task ModernPost_IgnoresMcpSessionIdHeader() + { + await StartHybridServerAsync(); + + // SEP-2567 removed sessions from the 2026-07-28 revision, so a stray session ID must neither be honored + // nor looked up against the stateful session manager the hybrid endpoint keeps for legacy clients. + using var response = await SendAsync(HttpMethod.Post, McpProtocolVersions.July2026ProtocolVersion, DiscoverRequest, + mcpMethod: "server/discover", sessionId: "non-existent-session-id"); + + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + Assert.False(response.Headers.Contains("Mcp-Session-Id")); + } + + [Fact] + public async Task LegacyGetAndDelete_RemainAvailable_WhileModernGetAndDeleteReturn405() + { + await StartHybridServerAsync(); + + using var initializeResponse = await SendAsync(HttpMethod.Post, protocolVersion: null, InitializeRequest); + var sessionId = Assert.Single(initializeResponse.Headers.GetValues("Mcp-Session-Id")); + + // The GET and DELETE endpoints are still mapped, so legacy clients keep the unsolicited-message stream + // and explicit session termination. + using var legacyGet = await SendAsync(HttpMethod.Get, McpProtocolVersions.November2025ProtocolVersion, content: null, sessionId: sessionId); + Assert.Equal(HttpStatusCode.OK, legacyGet.StatusCode); + + using var modernGet = await SendAsync(HttpMethod.Get, McpProtocolVersions.July2026ProtocolVersion, content: null); + Assert.Equal(HttpStatusCode.MethodNotAllowed, modernGet.StatusCode); + Assert.Equal(["POST"], modernGet.Content.Headers.Allow); + + using var modernDelete = await SendAsync(HttpMethod.Delete, McpProtocolVersions.July2026ProtocolVersion, content: null); + Assert.Equal(HttpStatusCode.MethodNotAllowed, modernDelete.StatusCode); + Assert.Equal(["POST"], modernDelete.Content.Headers.Allow); + + using var legacyDelete = await SendAsync(HttpMethod.Delete, McpProtocolVersions.November2025ProtocolVersion, content: null, sessionId: sessionId); + Assert.Equal(HttpStatusCode.OK, legacyDelete.StatusCode); + + // The session is gone, which proves the legacy DELETE was honored rather than short-circuited. + using var afterDelete = await SendAsync(HttpMethod.Post, McpProtocolVersions.November2025ProtocolVersion, ListToolsRequest, sessionId: sessionId); + Assert.Equal(HttpStatusCode.NotFound, afterDelete.StatusCode); + } + + private Task SendAsync( + HttpMethod method, + string? protocolVersion, + string? content = null, + string? mcpMethod = null, + string? sessionId = null) + { + var request = new HttpRequestMessage(method, ""); + request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); + request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("text/event-stream")); + + if (protocolVersion is not null) + { + request.Headers.Add("MCP-Protocol-Version", protocolVersion); + } + + if (mcpMethod is not null) + { + request.Headers.Add("Mcp-Method", mcpMethod); + } + + if (sessionId is not null) + { + request.Headers.Add("Mcp-Session-Id", sessionId); + } + + if (content is not null) + { + request.Content = new StringContent(content, Encoding.UTF8, "application/json"); + } + + return HttpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, TestContext.Current.CancellationToken); + } + + private static string DiscoverRequest => """ + {"jsonrpc":"2.0","id":1,"method":"server/discover","params":{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"HybridTestClient","version":"1.0"},"io.modelcontextprotocol/clientCapabilities":{}}}} + """; + + private static string InitializeRequest => """ + {"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-11-25","capabilities":{},"clientInfo":{"name":"HybridTestClient","version":"1.0"}}} + """; + + private static string ListToolsRequest => """ + {"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}} + """; + + public class ScopedService + { + public string? State { get; set; } + } +} diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/July2026ProtocolStatefulFallbackTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/July2026ProtocolStatefulFallbackTests.cs new file mode 100644 index 000000000..142536b9d --- /dev/null +++ b/tests/ModelContextProtocol.AspNetCore.Tests/July2026ProtocolStatefulFallbackTests.cs @@ -0,0 +1,148 @@ +using Microsoft.AspNetCore.Builder; +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.AspNetCore.Tests.Utils; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using ModelContextProtocol.Tests.Utils; +using System.Text.Json; + +namespace ModelContextProtocol.AspNetCore.Tests; + +/// +/// End-to-end coverage for a default (2026-07-28-first) client connecting to a real C# Streamable HTTP +/// server that deliberately opted into sessions using either +/// or . Starting with the 2026-07-28 protocol revision, +/// Streamable HTTP no longer supports sessions (SEP-2567 / SEP-2575), so the server refuses the probe with +/// -32022 UnsupportedProtocolVersion. The client must then auto-downgrade to the initialize +/// handshake, obtain the stateful session the server author opted into, and continue to work, including a +/// server-to-client elicitation round-trip resolved over the stateful session via the initialize-handshake +/// backcompat resolver. +/// +public class July2026ProtocolStatefulFallbackTests(ITestOutputHelper outputHelper) : KestrelInMemoryTest(outputHelper), IAsyncDisposable +{ + private WebApplication? _app; + + public async ValueTask DisposeAsync() + { + if (_app is not null) + { + await _app.DisposeAsync(); + } + base.Dispose(); + } + + [McpServerTool(Name = "greet")] + private static string Greet([System.ComponentModel.Description("Name to greet")] string name) => $"Hello, {name}!"; + + [McpServerTool(Name = "greet_via_elicit")] + private static async Task GreetViaElicit(McpServer server, CancellationToken cancellationToken) + { + // Server-to-client round-trip: only works when the session is stateful, which is exactly what + // the initialize fallback re-establishes for the 2026-07-28-first client. + var elicitResult = await server.ElicitAsync(new ElicitRequestParams + { + Message = "What is your name?", + RequestedSchema = new(), + }, cancellationToken); + + var name = elicitResult.Content?.TryGetValue("answer", out var answer) == true + ? answer.GetString() + : "stranger"; + + return $"Hello, {name}!"; + } + + private Task StartStatefulServerAsync() => + StartStatefulServerAsync(options => options.Stateless = false); + + private Task StartStatefulSessionModeServerAsync() => + StartStatefulServerAsync(options => options.SessionMode = HttpServerSessionMode.Stateful); + + private async Task StartStatefulServerAsync(Action configureTransport) + { + Builder.Services.AddMcpServer(options => + { + options.ServerInfo = new Implementation { Name = nameof(July2026ProtocolStatefulFallbackTests), Version = "1" }; + }) + .WithHttpTransport(configureTransport) + .WithTools([McpServerTool.Create(Greet), McpServerTool.Create(GreetViaElicit)]); + + _app = Builder.Build(); + _app.MapMcp(); + await _app.StartAsync(TestContext.Current.CancellationToken); + } + + private async Task ConnectDefaultClientAsync(Action? configureClient = null) + { + await using var transport = new HttpClientTransport(new HttpClientTransportOptions + { + Endpoint = new Uri("http://localhost:5000/"), + TransportMode = HttpTransportMode.StreamableHttp, + }, HttpClient, LoggerFactory); + + // Default options: ProtocolVersion is null, which now prefers the 2026-07-28 protocol revision and probes + // with server/discover before falling back to an initialize handshake. + var clientOptions = new McpClientOptions(); + configureClient?.Invoke(clientOptions); + return await McpClient.CreateAsync(transport, clientOptions, LoggerFactory, TestContext.Current.CancellationToken); + } + + [Fact] + public async Task DefaultClient_AgainstStatefulServer_DowngradesToInitialize_AndToolsWork() + { + await StartStatefulServerAsync(); + + await AssertDefaultClientDowngradesAndToolsWorkAsync(); + } + + [Fact] + public async Task DefaultClient_AgainstStatefulSessionMode_DowngradesToInitialize_AndToolsWork() + { + await StartStatefulSessionModeServerAsync(); + + await AssertDefaultClientDowngradesAndToolsWorkAsync(); + } + + private async Task AssertDefaultClientDowngradesAndToolsWorkAsync() + { + await using var client = await ConnectDefaultClientAsync(); + + // The 2026-07-28 probe was refused (-32022), so the client downgraded to initialize. + Assert.Equal(McpProtocolVersions.November2025ProtocolVersion, client.NegotiatedProtocolVersion); + + var result = await client.CallToolAsync("greet", + new Dictionary { ["name"] = "Alice" }, + cancellationToken: TestContext.Current.CancellationToken); + + var text = Assert.IsType(Assert.Single(result.Content)).Text; + Assert.Equal("Hello, Alice!", text); + } + + [Fact] + public async Task DefaultClient_AgainstStatefulServer_ServerToClientElicitation_RoundTrips() + { + await StartStatefulServerAsync(); + + await using var client = await ConnectDefaultClientAsync(options => + { + options.Handlers.ElicitationHandler = (request, ct) => new ValueTask(new ElicitResult + { + Action = "accept", + Content = new Dictionary + { + ["answer"] = JsonDocument.Parse("\"Bob\"").RootElement.Clone(), + }, + }); + }); + + Assert.Equal(McpProtocolVersions.November2025ProtocolVersion, client.NegotiatedProtocolVersion); + + var result = await client.CallToolAsync("greet_via_elicit", + cancellationToken: TestContext.Current.CancellationToken); + + var text = Assert.IsType(Assert.Single(result.Content)).Text; + Assert.Equal("Hello, Bob!", text); + Assert.True(result.IsError is not true); + } +} diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/MapMcpSseTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/MapMcpSseTests.cs index b796d78c2..05f9bdff3 100644 --- a/tests/ModelContextProtocol.AspNetCore.Tests/MapMcpSseTests.cs +++ b/tests/ModelContextProtocol.AspNetCore.Tests/MapMcpSseTests.cs @@ -1,4 +1,4 @@ -using Microsoft.AspNetCore.Builder; +using Microsoft.AspNetCore.Builder; using Microsoft.Extensions.DependencyInjection; using ModelContextProtocol.Protocol; using ModelContextProtocol.Server; @@ -21,7 +21,7 @@ protected override void ConfigureStateless(HttpServerTransportOptions options) [InlineData("/mcp/secondary")] public async Task Allows_Customizing_Route(string pattern) { - Builder.Services.AddMcpServer().WithHttpTransport(options => options.EnableLegacySse = true); + Builder.Services.AddMcpServer().WithHttpTransport(options => { options.EnableLegacySse = true; options.Stateless = false; }); await using var app = Builder.Build(); app.MapMcp(pattern); @@ -53,7 +53,7 @@ public async Task CanConnect_WithMcpClient_AfterCustomizingRoute(string routePat Name = "TestCustomRouteServer", Version = "1.0.0", }; - }).WithHttpTransport(options => options.EnableLegacySse = true); + }).WithHttpTransport(options => { options.EnableLegacySse = true; options.Stateless = false; }); await using var app = Builder.Build(); app.MapMcp(routePattern); @@ -83,7 +83,7 @@ public async Task EnablePollingAsync_ThrowsInvalidOperationException_InSseMode() return "Complete"; }, options: new() { Name = "polling_tool" }); - Builder.Services.AddMcpServer().WithHttpTransport(options => options.EnableLegacySse = true).WithTools([pollingTool]); + Builder.Services.AddMcpServer().WithHttpTransport(options => { options.EnableLegacySse = true; options.Stateless = false; }).WithTools([pollingTool]); await using var app = Builder.Build(); app.MapMcp(); diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/MapMcpStatelessTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/MapMcpStatelessTests.cs index 5552b5395..ac19953bf 100644 --- a/tests/ModelContextProtocol.AspNetCore.Tests/MapMcpStatelessTests.cs +++ b/tests/ModelContextProtocol.AspNetCore.Tests/MapMcpStatelessTests.cs @@ -1,7 +1,45 @@ -namespace ModelContextProtocol.AspNetCore.Tests; +using Microsoft.AspNetCore.Builder; +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; + +namespace ModelContextProtocol.AspNetCore.Tests; public class MapMcpStatelessTests(ITestOutputHelper outputHelper) : MapMcpStreamableHttpTests(outputHelper) { protected override bool UseStreamableHttp => true; protected override bool Stateless => true; + + [Fact] + public async Task EnablePollingAsync_ThrowsInvalidOperationException_InStatelessMode() + { + InvalidOperationException? capturedException = null; + var pollingTool = McpServerTool.Create(async (RequestContext context) => + { + try + { + await context.EnablePollingAsync(retryInterval: TimeSpan.FromSeconds(1)); + } + catch (InvalidOperationException ex) + { + capturedException = ex; + } + + return "Complete"; + }, options: new() { Name = "polling_tool" }); + + Builder.Services.AddMcpServer().WithHttpTransport(ConfigureStateless).WithTools([pollingTool]); + + await using var app = Builder.Build(); + app.MapMcp(); + + await app.StartAsync(TestContext.Current.CancellationToken); + + await using var mcpClient = await ConnectAsync(); + + await mcpClient.CallToolAsync("polling_tool", cancellationToken: TestContext.Current.CancellationToken); + + Assert.NotNull(capturedException); + Assert.Contains("stateless", capturedException.Message, StringComparison.OrdinalIgnoreCase); + } } diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/MapMcpStreamableHttpTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/MapMcpStreamableHttpTests.cs index 4f2d5aaeb..889a7daab 100644 --- a/tests/ModelContextProtocol.AspNetCore.Tests/MapMcpStreamableHttpTests.cs +++ b/tests/ModelContextProtocol.AspNetCore.Tests/MapMcpStreamableHttpTests.cs @@ -8,6 +8,7 @@ using ModelContextProtocol.Tests.Utils; using System.Collections.Concurrent; using System.Net; +using System.Security.Claims; using System.Threading; using System.Threading.Tasks; @@ -347,9 +348,9 @@ public async Task StreamableHttpClient_SendsMcpProtocolVersionHeader_AfterInitia await app.StartAsync(TestContext.Current.CancellationToken); - await using var mcpClient = await ConnectAsync(clientOptions: new() + await using var mcpClient = await ConnectAsync(configureClient: options => { - ProtocolVersion = "2025-06-18", + options.ProtocolVersion = "2025-06-18"; }); Assert.Equal("2025-06-18", mcpClient.NegotiatedProtocolVersion); @@ -409,7 +410,7 @@ public async Task CanResumeSessionWithMapMcpAndRunSessionHandler() OwnsSession = false, }, HttpClient, LoggerFactory); - await using (var initialClient = await McpClient.CreateAsync(initialTransport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)) + await using (var initialClient = await McpClient.CreateAsync(initialTransport, new McpClientOptions { ProtocolVersion = "2025-11-25" }, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)) { resumedSessionId = initialClient.SessionId ?? throw new InvalidOperationException("SessionId not negotiated."); serverCapabilities = initialClient.ServerCapabilities; @@ -457,41 +458,6 @@ public async Task CanResumeSessionWithMapMcpAndRunSessionHandler() Assert.Equal(1, runSessionCount); } - [Fact] - public async Task EnablePollingAsync_ThrowsInvalidOperationException_InStatelessMode() - { - Assert.SkipUnless(Stateless, "This test only applies to stateless mode."); - - InvalidOperationException? capturedException = null; - var pollingTool = McpServerTool.Create(async (RequestContext context) => - { - try - { - await context.EnablePollingAsync(retryInterval: TimeSpan.FromSeconds(1)); - } - catch (InvalidOperationException ex) - { - capturedException = ex; - } - - return "Complete"; - }, options: new() { Name = "polling_tool" }); - - Builder.Services.AddMcpServer().WithHttpTransport(ConfigureStateless).WithTools([pollingTool]); - - await using var app = Builder.Build(); - app.MapMcp(); - - await app.StartAsync(TestContext.Current.CancellationToken); - - await using var mcpClient = await ConnectAsync(); - - await mcpClient.CallToolAsync("polling_tool", cancellationToken: TestContext.Current.CancellationToken); - - Assert.NotNull(capturedException); - Assert.Contains("stateless", capturedException.Message, StringComparison.OrdinalIgnoreCase); - } - [Fact] public async Task EnablePollingAsync_ThrowsInvalidOperationException_WhenNoEventStreamStoreConfigured() { @@ -520,7 +486,9 @@ public async Task EnablePollingAsync_ThrowsInvalidOperationException_WhenNoEvent await app.StartAsync(TestContext.Current.CancellationToken); - await using var mcpClient = await ConnectAsync(); + // Polling via an event-stream store is a stateful-session feature. Starting with the 2026-07-28 + // protocol revision, Streamable HTTP no longer supports sessions, so pin to the latest stable version to keep exercising the stateful path. + await using var mcpClient = await ConnectAsync(configureClient: options => options.ProtocolVersion = "2025-11-25"); await mcpClient.CallToolAsync("polling_tool", cancellationToken: TestContext.Current.CancellationToken); @@ -572,7 +540,9 @@ public async Task AdditionalHeaders_AreSent_InPostAndDeleteRequests() }, }; - await using var mcpClient = await ConnectAsync(transportOptions: transportOptions); + // DELETE requests are only sent when there's a session ID to delete - a legacy stateful + // behavior. Starting with the 2026-07-28 protocol revision, Streamable HTTP no longer supports sessions. Pin to the latest stable version. + await using var mcpClient = await ConnectAsync(transportOptions: transportOptions, configureClient: options => options.ProtocolVersion = "2025-11-25"); // Do a tool call to ensure there's more than just the initialize request await mcpClient.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); @@ -623,7 +593,7 @@ public async Task DisposeAsync_DoesNotHang_WhenOwnsSessionIsFalse() OwnsSession = false, }, HttpClient, LoggerFactory); - var client = await McpClient.CreateAsync(transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + var client = await McpClient.CreateAsync(transport, new McpClientOptions { ProtocolVersion = "2025-11-25" }, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); // Call a tool to ensure the session is fully established var result = await client.CallToolAsync( @@ -691,7 +661,7 @@ public async Task DisposeAsync_DoesNotHang_WhenOwnsSessionIsFalse_WithUnsolicite OwnsSession = false, }, HttpClient, LoggerFactory); - var client = await McpClient.CreateAsync(transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + var client = await McpClient.CreateAsync(transport, new McpClientOptions { ProtocolVersion = "2025-11-25" }, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); var result = await client.CallToolAsync( "echo_claims_principal", @@ -751,7 +721,9 @@ public async Task Client_CanReconnect_AfterSessionExpiry() await app.StartAsync(TestContext.Current.CancellationToken); // Connect the first client and verify it works. - var client1 = await ConnectAsync(); + // Server-side session expiry and reconnect rely on session IDs, a legacy stateful behavior. + // Starting with the 2026-07-28 protocol revision, Streamable HTTP no longer supports sessions. Pin both clients to the latest stable version. + var client1 = await ConnectAsync(configureClient: options => options.ProtocolVersion = "2025-11-25"); var originalSessionId = client1.SessionId; Assert.NotNull(originalSessionId); @@ -773,7 +745,7 @@ await Assert.ThrowsAnyAsync(async () => await client1.DisposeAsync(); // Reconnect with a brand-new session. - await using var client2 = await ConnectAsync(); + await using var client2 = await ConnectAsync(configureClient: options => options.ProtocolVersion = "2025-11-25"); Assert.NotNull(client2.SessionId); Assert.NotEqual(originalSessionId, client2.SessionId); @@ -787,18 +759,19 @@ public async Task EndpointFilter_CanReadSessionId_BeforeAndAfterHandler() { var capturedSessionIds = new ConcurrentBag<(string? BeforeNext, string? AfterNext, string Method)>(); var capturedActivityTags = new ConcurrentBag<(string? TagValue, bool HadActivity, string Method)>(); + var requestObserved = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); Builder.Services.AddMcpServer().WithHttpTransport(ConfigureStateless).WithTools(); await using var app = Builder.Build(); - // This is the pattern documented in sessions.md — verify it actually works. + // This is the pattern documented in sessions.md - verify it actually works. // Tag before next() so child spans inherit the value. app.MapMcp().AddEndpointFilter(async (context, next) => { var httpContext = context.HttpContext; - // Read from request headers — available on all non-initialize requests in stateful mode. + // Read from request headers - available on all non-initialize requests in stateful mode. string? beforeSessionId = httpContext.Request.Headers["Mcp-Session-Id"]; // Tag before next() so child activities created during the handler inherit it. @@ -816,18 +789,31 @@ public async Task EndpointFilter_CanReadSessionId_BeforeAndAfterHandler() capturedSessionIds.Add((beforeSessionId, afterSessionId, httpContext.Request.Method)); capturedActivityTags.Add((tagValue, activity is not null, httpContext.Request.Method)); + requestObserved.TrySetResult(); return result; }); await app.StartAsync(TestContext.Current.CancellationToken); - await using var client = await ConnectAsync(); + // The stateful (else) branch below asserts session-ID behavior, which only exists under the + // legacy handshake. Starting with the 2026-07-28 protocol revision, Streamable HTTP no longer supports sessions. Pin legacy only for the stateful variant. + await using var client = await ConnectAsync(configureClient: options => + { + if (!Stateless) + { + options.ProtocolVersion = "2025-11-25"; + } + }); await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); - // The filter must have observed at least one MCP request. Don't assert an exact - // minimum — the initialized notification or GET stream may not have completed yet. + // The filter records into the bag *after* await next(context) returns. For a streamed SSE + // response the client can observe completion (and ListToolsAsync can return) before that + // server-side continuation runs, so asserting the bag immediately races. Wait for the filter + // to record at least one request first. Don't assert an exact minimum - the initialized + // notification or GET stream may not have completed yet. + await requestObserved.Task.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); Assert.NotEmpty(capturedSessionIds); if (Stateless) @@ -854,7 +840,7 @@ public async Task EndpointFilter_CanReadSessionId_BeforeAndAfterHandler() }); // At least one POST should have the session ID in the request header too - // (the initialized notification or list_tools — but not the initial initialize request). + // (the initialized notification or list_tools - but not the initial initialize request). Assert.Contains(postCaptures, c => c.BeforeNext == client.SessionId); // Verify Activity.Current was available and the AddTag pattern works before next(). @@ -868,4 +854,76 @@ public async Task EndpointFilter_CanReadSessionId_BeforeAndAfterHandler() }); } } + + [Fact] + public async Task DeleteRequest_FromDifferentUser_IsRejected_AndSessionSurvives() + { + Assert.SkipWhen(Stateless, "Sessions don't exist in stateless mode."); + + Builder.Services.AddMcpServer().WithHttpTransport(ConfigureStateless).WithTools(); + Builder.Services.AddHttpContextAccessor(); + + await using var app = Builder.Build(); + + // Pick the user from a test header so different HttpClient requests can act as different users. + app.Use(next => async context => + { + var name = context.Request.Headers["X-Test-User"].ToString(); + if (!string.IsNullOrEmpty(name)) + { + context.User = new ClaimsPrincipal(new ClaimsIdentity( + [new Claim("name", name), new Claim(ClaimTypes.NameIdentifier, name)], + "TestAuthType", "name", "role")); + } + await next(context); + }); + + app.MapMcp(); + await app.StartAsync(TestContext.Current.CancellationToken); + + const string initializeRequest = """ + {"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"test-client","version":"1.0.0"}}} + """; + + using var initRequest = new HttpRequestMessage(HttpMethod.Post, "http://localhost:5000/") + { + Content = new StringContent(initializeRequest, System.Text.Encoding.UTF8, "application/json"), + }; + initRequest.Headers.Add("X-Test-User", "Alice"); + initRequest.Headers.Accept.ParseAdd("application/json"); + initRequest.Headers.Accept.ParseAdd("text/event-stream"); + + using var initResponse = await HttpClient.SendAsync(initRequest, TestContext.Current.CancellationToken); + Assert.True(initResponse.IsSuccessStatusCode); + var sessionId = Assert.Single(initResponse.Headers.GetValues("Mcp-Session-Id")); + + // A DELETE from a different authenticated user must not be able to tear down Alice's session. + using var bobDelete = new HttpRequestMessage(HttpMethod.Delete, "http://localhost:5000/"); + bobDelete.Headers.Add("X-Test-User", "Bob"); + bobDelete.Headers.Add("Mcp-Session-Id", sessionId); + using var bobDeleteResponse = await HttpClient.SendAsync(bobDelete, TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.Forbidden, bobDeleteResponse.StatusCode); + + // Alice should still be able to use the session. + const string toolCallRequest = """ + {"jsonrpc":"2.0","id":2,"method":"tools/list"} + """; + using var aliceCall = new HttpRequestMessage(HttpMethod.Post, "http://localhost:5000/") + { + Content = new StringContent(toolCallRequest, System.Text.Encoding.UTF8, "application/json"), + }; + aliceCall.Headers.Add("X-Test-User", "Alice"); + aliceCall.Headers.Add("Mcp-Session-Id", sessionId); + aliceCall.Headers.Accept.ParseAdd("application/json"); + aliceCall.Headers.Accept.ParseAdd("text/event-stream"); + using var aliceCallResponse = await HttpClient.SendAsync(aliceCall, TestContext.Current.CancellationToken); + Assert.True(aliceCallResponse.IsSuccessStatusCode); + + // Alice can still terminate her own session. + using var aliceDelete = new HttpRequestMessage(HttpMethod.Delete, "http://localhost:5000/"); + aliceDelete.Headers.Add("X-Test-User", "Alice"); + aliceDelete.Headers.Add("Mcp-Session-Id", sessionId); + using var aliceDeleteResponse = await HttpClient.SendAsync(aliceDelete, TestContext.Current.CancellationToken); + Assert.True(aliceDeleteResponse.IsSuccessStatusCode); + } } diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/MapMcpTests.Mrtr.cs b/tests/ModelContextProtocol.AspNetCore.Tests/MapMcpTests.Mrtr.cs new file mode 100644 index 000000000..03af131b4 --- /dev/null +++ b/tests/ModelContextProtocol.AspNetCore.Tests/MapMcpTests.Mrtr.cs @@ -0,0 +1,820 @@ +using Microsoft.AspNetCore.Builder; +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using ModelContextProtocol.Tests.Utils; +using System.Text.Json; + +namespace ModelContextProtocol.AspNetCore.Tests; + +public abstract partial class MapMcpTests +{ + // Starting with the 2026-07-28 protocol revision, Streamable HTTP no longer supports sessions (SEP-2567): + // the handler refuses a request when the server opted into sessions (SessionMode = HttpServerSessionMode.Stateful), so a client pinned + // to that revision downgrades to legacy instead of negotiating 2026-07-28. These MRTR tests therefore can't + // run on the stateful Streamable HTTP fixture; the same coverage runs on the stateless and legacy-SSE fixtures. + private const string July2026StatefulStreamableHttpSkipReason = + "Starting with the 2026-07-28 protocol revision, Streamable HTTP no longer supports sessions (SEP-2567); stateful Streamable HTTP refuses it. Covered by the stateless and SSE fixtures."; + + private ServerMessageTracker ConfigureServer(params Delegate[] tools) + { + var messageTracker = new ServerMessageTracker(); + Builder.Services.AddMcpServer(options => + { + options.ServerInfo = new Implementation { Name = "MrtrTestServer", Version = "1" }; + // Do not pin a protocol version - let it be negotiated based on what the client requests. + // 2026-07-28 is in SupportedProtocolVersions, so an opt-in client gets it; others get + // the latest legacy version. + messageTracker.AddFilters(options.Filters.Message); + }) + .WithHttpTransport(ConfigureStateless) + .WithTools(tools.Select(t => McpServerTool.Create(t))); + return messageTracker; + } + + private Task ConnectExperimentalAsync() => + ConnectAsync(configureClient: options => + { + ConfigureMrtrHandlers(options); + options.ProtocolVersion = "2026-07-28"; + }); + + // The default client now negotiates the 2026-07-28 protocol revision. The legacy + // JSON-RPC MRTR back-compat resolver only applies to legacy clients, so pin these to the latest legacy version. + private Task ConnectLegacyAsync() => + ConnectAsync(configureClient: options => + { + ConfigureMrtrHandlers(options); + options.ProtocolVersion = "2025-11-25"; + }); + + /// Configures elicitation, sampling, and roots handlers on client options. + private static void ConfigureMrtrHandlers(McpClientOptions options) + { + options.Handlers.ElicitationHandler = (request, ct) => + { + var message = request?.Message ?? ""; + var answer = message.Contains("name", StringComparison.OrdinalIgnoreCase) ? "Alice" + : message.Contains("greet", StringComparison.OrdinalIgnoreCase) ? "Hello" + : "yes"; + + return new ValueTask(new ElicitResult + { + Action = "accept", + Content = new Dictionary + { + ["answer"] = JsonDocument.Parse($"\"{answer}\"").RootElement.Clone() + } + }); + }; + options.Handlers.SamplingHandler = (request, progress, ct) => + { + var prompt = request?.Messages?.LastOrDefault()?.Content + .OfType().FirstOrDefault()?.Text ?? ""; + return new ValueTask(new CreateMessageResult + { + Content = [new TextContentBlock { Text = $"LLM:{prompt}" }], + Model = "test-model" + }); + }; + options.Handlers.RootsHandler = (request, ct) => + { + return new ValueTask(new ListRootsResult + { + Roots = [ + new Root { Uri = "file:///project", Name = "Project" }, + new Root { Uri = "file:///data", Name = "Data" } + ] + }); + }; + } + + // ===================================================================== + // MRTR tests: experimental (native), backcompat (legacy JSON-RPC), and edge cases. + // Each test creates its own server with 2026-07-28 enabled. + // ===================================================================== + + [McpServerTool(Name = "mrtr-mixed")] + private static async Task MrtrMixed(McpServer server, RequestContext context, CancellationToken ct) + { + var state = context.Params!.RequestState; + var responses = context.Params!.InputResponses; + + // Round 3 entry: confirmation from round 2 available. Transition to await API. + if (state == "round-2" && responses?.TryGetValue("confirm", out var confirmResponse) == true) + { + var confirmation = confirmResponse.Deserialize(InputResponse.ElicitResultJsonTypeInfo)?.Action ?? "unknown"; + + // Await API: sequential sampling then elicitation + var sampleResult = await server.SampleAsync(new CreateMessageRequestParams + { + Messages = [new SamplingMessage { Role = Role.User, Content = [new TextContentBlock { Text = "Write greeting" }] }], + MaxTokens = 100 + }, ct); + var greeting = sampleResult.Content.OfType().FirstOrDefault()?.Text ?? ""; + + var signoffResult = await server.ElicitAsync(new ElicitRequestParams + { + Message = "Sign off as?", + RequestedSchema = new() + }, ct); + var signoff = signoffResult.Action; + + return $"{confirmation}|{greeting}|{signoff}"; + } + + // Round 2 entry: parallel results from round 1 available. + if (state == "round-1" && responses is not null) + { + var name = responses["name"].Deserialize(InputResponse.ElicitResultJsonTypeInfo)?.Content?.FirstOrDefault().Value; + var weather = responses["weather"].Deserialize(InputResponse.CreateMessageResultJsonTypeInfo)?.Content + .OfType().FirstOrDefault()?.Text ?? ""; + var root = responses["roots"].Deserialize(InputResponse.ListRootsResultJsonTypeInfo)?.Roots?.FirstOrDefault()?.Name ?? ""; + + // Exception API: single elicitation with requestState + throw new InputRequiredException( + inputRequests: new Dictionary + { + ["confirm"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = $"Confirm {name} in {weather} near {root}?", + RequestedSchema = new() + }) + }, + requestState: "round-2"); + } + + // Round 1: Exception API with 3 PARALLEL input requests + throw new InputRequiredException( + inputRequests: new Dictionary + { + ["name"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "What is your name?", + RequestedSchema = new() + }), + ["weather"] = InputRequest.ForSampling(new CreateMessageRequestParams + { + Messages = [new SamplingMessage { Role = Role.User, Content = [new TextContentBlock { Text = "Describe the weather" }] }], + MaxTokens = 100 + }), + ["roots"] = InputRequest.ForRootsList(new ListRootsRequestParams()) + }, + requestState: "round-1"); + } + + [Theory] + [InlineData(false)] + [InlineData(true)] + public async Task Mrtr_MixedExceptionAndAwaitStyle(bool experimentalClient) + { + // the await-style portion of this tool calls server.SampleAsync/ElicitAsync on round 3, + // which requires server-to-client requests - only available in stateful sessions. Starting with + // the 2026-07-28 protocol revision (SEP-2567), Streamable HTTP is implicitly stateless, so the + // experimental-client + HTTP combination cannot resolve the await-style portion. Stdio + // coverage for this scenario lives in July2026ProtocolBackcompatTests. + Assert.SkipWhen(experimentalClient, "Await-style MRTR requires session affinity; starting with the 2026-07-28 protocol revision (SEP-2567) Streamable HTTP no longer supports sessions. See July2026ProtocolBackcompatTests for stdio coverage."); + + // The server always supports 2026-07-28 (it's in SupportedProtocolVersions). The + // client opts in by pinning ProtocolVersion = "2026-07-28"; otherwise it negotiates + // the latest legacy version and the server falls back to the exception path with + // legacy JSON-RPC resolution. + var messageTracker = ConfigureServer(MrtrMixed); + + await using var app = Builder.Build(); + app.MapMcp(); + await app.StartAsync(TestContext.Current.CancellationToken); + + Action configureClient = experimentalClient + ? options => { ConfigureMrtrHandlers(options); options.ProtocolVersion = "2026-07-28"; } + // ProtocolVersion null now defaults to the 2026-07-28 protocol revision, so pin the legacy client explicitly to keep dual-era coverage. + : options => { ConfigureMrtrHandlers(options); options.ProtocolVersion = "2025-11-25"; }; + + // The await-style portion of this tool calls server.SampleAsync/ElicitAsync on round 3. + // In stateless mode, those calls succeed only when the request is still open on the same + // SSE stream - which it is - so the tool runs end-to-end as long as the input requests + // themselves can be resolved (MRTR client) or replayed via legacy JSON-RPC (stateful + legacy). + if (Stateless && !experimentalClient) + { + // Stateless + legacy client: InputRequiredException cannot be resolved (no MRTR wire + // and no persistent server instance for the backcompat retry loop). The server returns + // a JSON-RPC error. + await using var client = await ConnectAsync(configureClient: configureClient); + + var ex = await Assert.ThrowsAsync(() => + client.CallToolAsync("mrtr-mixed", + cancellationToken: TestContext.Current.CancellationToken).AsTask()); + + Assert.Equal(McpErrorCode.InternalError, ex.ErrorCode); + Assert.Contains("stateless", ex.Message, StringComparison.OrdinalIgnoreCase); + Assert.Contains("MRTR", ex.Message); + return; + } + + if (Stateless && experimentalClient) + { + // Stateless + MRTR client: the await-style portion (server.SampleAsync on round 3) + // requires handler suspension across requests, which only works in stateful mode. + // Skip this combination - the await API is documented as stateful-only. + Assert.SkipWhen(true, "Await-style API requires handler suspension (stateful only)."); + return; + } + + // Stateful path - both client modes complete all 3 rounds. + await using var statefulClient = await ConnectAsync(configureClient: configureClient); + + Assert.Equal(experimentalClient ? "2026-07-28" : "2025-11-25", + statefulClient.NegotiatedProtocolVersion); + + var result = await statefulClient.CallToolAsync("mrtr-mixed", + cancellationToken: TestContext.Current.CancellationToken); + + var text = Assert.IsType(Assert.Single(result.Content)).Text; + Assert.True(result.IsError is not true); + var parts = text.Split('|'); + Assert.Equal(3, parts.Length); + Assert.Equal("accept", parts[0]); + Assert.StartsWith("LLM:", parts[1]); + Assert.Equal("accept", parts[2]); + + if (experimentalClient) + { + // Rounds 1-2 use wire-format MRTR (InputRequiredResult), but round 3's await calls + // still issue legacy elicitation/create + sampling/createMessage requests, so this + // configuration is mixed-mode. + messageTracker.AssertMrtrUsedAtLeastOnce(); + } + else + { + messageTracker.AssertMrtrNotUsed(); + } + } + + [McpServerTool(Name = "mrtr-parallel-await")] + private static async Task MrtrParallelAwait(McpServer server, CancellationToken ct) + { + var elicitTask = server.ElicitAsync(new ElicitRequestParams + { + Message = "Parallel elicit", + RequestedSchema = new() + }, ct); + + // Start the second await - with MRTR, this throws InvalidOperationException + // because MrtrContext only supports one pending exchange at a time. + try + { + var sampleTask = server.SampleAsync(new CreateMessageRequestParams + { + Messages = [new SamplingMessage { Role = Role.User, Content = [new TextContentBlock { Text = "Parallel sample" }] }], + MaxTokens = 100 + }, ct); + + // If we get here, both calls succeeded (non-MRTR path) + var sampleResult = await sampleTask; + var elicitResult = await elicitTask; + return $"parallel-ok:{elicitResult.Action}:{sampleResult.Content.OfType().First().Text}"; + } + catch (InvalidOperationException ex) + { + return ex.Message; + } + } + + [Theory] + [InlineData(false)] + [InlineData(true)] + public async Task Mrtr_ParallelAwaits(bool experimentalClient) + { + // Parallel awaits work with regular JSON-RPC but fail with MRTR because + // MrtrContext only supports one exchange at a time (TrySetResult gate). + Assert.SkipWhen(Stateless, "Await-style API requires handler suspension (stateful only)."); + // Starting with the 2026-07-28 protocol revision (SEP-2567), the server is implicitly stateless for + // clients on that revision, so parallel-await MRTR can't reach its concurrency gate. Skip the experimental-client + // case for the same reason as Mrtr_MixedExceptionAndAwaitStyle. + Assert.SkipWhen(experimentalClient, "Await-style MRTR requires session affinity; starting with the 2026-07-28 protocol revision (SEP-2567) Streamable HTTP no longer supports sessions."); + + ConfigureServer(MrtrParallelAwait); + await using var app = Builder.Build(); + app.MapMcp(); + await app.StartAsync(TestContext.Current.CancellationToken); + + Action configureClient = experimentalClient + ? options => { ConfigureMrtrHandlers(options); options.ProtocolVersion = "2026-07-28"; } + // ProtocolVersion null now defaults to the 2026-07-28 protocol revision, so pin the legacy client explicitly to keep dual-era coverage. + : options => { ConfigureMrtrHandlers(options); options.ProtocolVersion = "2025-11-25"; }; + + await using var client = await ConnectAsync(configureClient: configureClient); + + if (experimentalClient) + { + // MRTR active. Parallel awaits hit the MrtrContext concurrency gate and the second + // call throws InvalidOperationException, which the tool catches and returns as text. + Assert.Equal("2026-07-28", client.NegotiatedProtocolVersion); + + var result = await client.CallToolAsync("mrtr-parallel-await", + cancellationToken: TestContext.Current.CancellationToken); + + var text = Assert.IsType(Assert.Single(result.Content)).Text; + Assert.Contains("Concurrent server-to-client requests are not supported", text); + Assert.True(result.IsError is not true); + } + else + { + // Non-MRTR: awaits go through regular JSON-RPC - concurrent calls work. + Assert.Equal("2025-11-25", client.NegotiatedProtocolVersion); + + var result = await client.CallToolAsync("mrtr-parallel-await", + cancellationToken: TestContext.Current.CancellationToken); + + var text = Assert.IsType(Assert.Single(result.Content)).Text; + Assert.StartsWith("parallel-ok:", text); + Assert.True(result.IsError is not true); + } + } + + [McpServerTool(Name = "mrtr-elicit")] + private static string MrtrElicit(RequestContext context) + { + if (context.Params!.InputResponses is { } responses && + responses.TryGetValue("user_input", out var response)) + { + return $"elicit-ok:{response.Deserialize(InputResponse.ElicitResultJsonTypeInfo)?.Action}"; + } + + throw new InputRequiredException( + inputRequests: new Dictionary + { + ["user_input"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "Please confirm", + RequestedSchema = new() + }) + }, + requestState: "elicit-state"); + } + + [Fact] + public async Task Mrtr_Roots_CompletesViaMrtr() + { + Assert.SkipWhen(UseStreamableHttp && !Stateless, July2026StatefulStreamableHttpSkipReason); + + var messageTracker = ConfigureServer( + [McpServerTool(Name = "mrtr-roots")] (RequestContext context) => + { + if (context.Params!.InputResponses is { } responses && + responses.TryGetValue("roots", out var response)) + { + var roots = response.Deserialize(InputResponse.ListRootsResultJsonTypeInfo)?.Roots; + return $"roots-ok:{string.Join(",", roots?.Select(r => r.Uri) ?? [])}"; + } + + throw new InputRequiredException( + inputRequests: new Dictionary + { + ["roots"] = InputRequest.ForRootsList(new ListRootsRequestParams()) + }, + requestState: "roots-state"); + }); + await using var app = Builder.Build(); + app.MapMcp(); + await app.StartAsync(TestContext.Current.CancellationToken); + await using var client = await ConnectExperimentalAsync(); + Assert.Equal("2026-07-28", client.NegotiatedProtocolVersion); + + var result = await client.CallToolAsync("mrtr-roots", + cancellationToken: TestContext.Current.CancellationToken); + + var text = Assert.IsType(Assert.Single(result.Content)).Text; + Assert.Equal("roots-ok:file:///project,file:///data", text); + Assert.True(result.IsError is not true); + messageTracker.AssertMrtrUsed(); + } + + [McpServerTool(Name = "mrtr-multi")] + private static string MrtrMulti(RequestContext context) + { + var requestState = context.Params!.RequestState; + var inputResponses = context.Params!.InputResponses; + + if (requestState == "round-2" && inputResponses is not null) + { + var greeting = inputResponses["greeting"].Deserialize(InputResponse.ElicitResultJsonTypeInfo)?.Action; + return $"multi-done:greeting={greeting}"; + } + + if (requestState == "round-1" && inputResponses is not null) + { + var name = inputResponses["name"].Deserialize(InputResponse.ElicitResultJsonTypeInfo)?.Content?.FirstOrDefault().Value; + throw new InputRequiredException( + inputRequests: new Dictionary + { + ["greeting"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = $"How should I greet {name}?", + RequestedSchema = new() + }) + }, + requestState: "round-2"); + } + + throw new InputRequiredException( + inputRequests: new Dictionary + { + ["name"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "What is your name?", + RequestedSchema = new() + }) + }, + requestState: "round-1"); + } + + [Theory] + [InlineData(true)] + [InlineData(false)] + public async Task Mrtr_MultiRoundTrip_Completes(bool experimentalClient) + { + Assert.SkipWhen(experimentalClient && UseStreamableHttp && !Stateless, July2026StatefulStreamableHttpSkipReason); + + var messageTracker = ConfigureServer(MrtrMulti); + await using var app = Builder.Build(); + app.MapMcp(); + await app.StartAsync(TestContext.Current.CancellationToken); + + // Configure client - experimental or default based on parameter. + Action configureClient = experimentalClient + ? options => { ConfigureMrtrHandlers(options); options.ProtocolVersion = "2026-07-28"; } + // ProtocolVersion null now defaults to the 2026-07-28 protocol revision, so pin the legacy client explicitly to keep dual-era coverage. + : options => { ConfigureMrtrHandlers(options); options.ProtocolVersion = "2025-11-25"; }; + await using var client = await ConnectAsync(configureClient: configureClient); + + if (!experimentalClient && Stateless) + { + // Stateless without MRTR: InputRequiredException can't be resolved + // (no MRTR negotiated and no stateful backcompat path). + var ex = await Assert.ThrowsAsync(() => + client.CallToolAsync("mrtr-multi", + cancellationToken: TestContext.Current.CancellationToken).AsTask()); + Assert.Equal(McpErrorCode.InternalError, ex.ErrorCode); + return; + } + + var result = await client.CallToolAsync("mrtr-multi", + cancellationToken: TestContext.Current.CancellationToken); + + var text = Assert.IsType(Assert.Single(result.Content)).Text; + Assert.Equal("multi-done:greeting=accept", text); + Assert.True(result.IsError is not true); + + if (experimentalClient) + { + Assert.Equal("2026-07-28", client.NegotiatedProtocolVersion); + messageTracker.AssertMrtrUsed(); + } + else + { + Assert.Equal("2025-11-25", client.NegotiatedProtocolVersion); + messageTracker.AssertMrtrNotUsed(); + } + } + + [Theory] + [InlineData(true)] + [InlineData(false)] + public async Task Mrtr_IsMrtrSupported(bool experimentalClient) + { + Assert.SkipWhen(experimentalClient && UseStreamableHttp && !Stateless, July2026StatefulStreamableHttpSkipReason); + + ConfigureServer([McpServerTool(Name = "mrtr-check")] (McpServer server) => server.IsMrtrSupported.ToString()); + await using var app = Builder.Build(); + app.MapMcp(); + await app.StartAsync(TestContext.Current.CancellationToken); + + // Configure client - experimental or default based on parameter. + Action configureClient = experimentalClient + ? options => { ConfigureMrtrHandlers(options); options.ProtocolVersion = "2026-07-28"; } + // ProtocolVersion null now defaults to the 2026-07-28 protocol revision, so pin the legacy client explicitly to keep dual-era coverage. + : options => { ConfigureMrtrHandlers(options); options.ProtocolVersion = "2025-11-25"; }; + await using var client = await ConnectAsync(configureClient: configureClient); + Assert.Equal(experimentalClient ? "2026-07-28" : "2025-11-25", client.NegotiatedProtocolVersion); + + var result = await client.CallToolAsync("mrtr-check", + cancellationToken: TestContext.Current.CancellationToken); + + // IsMrtrSupported is false only when stateless AND client didn't negotiate MRTR + // (no backcompat path available). All other combos have MRTR or backcompat support. + var expected = Stateless && !experimentalClient ? "False" : "True"; + var text = Assert.IsType(Assert.Single(result.Content)).Text; + Assert.Equal(expected, text); + } + + [McpServerTool(Name = "mrtr-concurrent-three")] + private static string MrtrConcurrentThree(RequestContext context) + { + if (context.Params!.InputResponses is { Count: 3 } responses && + responses.ContainsKey("elicit") && + responses.ContainsKey("sample") && + responses.ContainsKey("roots")) + { + var elicitAction = responses["elicit"].Deserialize(InputResponse.ElicitResultJsonTypeInfo)?.Action; + var sampleText = responses["sample"].Deserialize(InputResponse.CreateMessageResultJsonTypeInfo)? + .Content.OfType().FirstOrDefault()?.Text; + var rootUris = string.Join(",", + responses["roots"].Deserialize(InputResponse.ListRootsResultJsonTypeInfo)?.Roots.Select(r => r.Uri) ?? []); + return $"all-ok:elicit={elicitAction},sample={sampleText},roots={rootUris}"; + } + + throw new InputRequiredException( + inputRequests: new Dictionary + { + ["elicit"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "Confirm action", + RequestedSchema = new() + }), + ["sample"] = InputRequest.ForSampling(new CreateMessageRequestParams + { + Messages = [new SamplingMessage + { + Role = Role.User, + Content = [new TextContentBlock { Text = "Generate summary" }] + }], + MaxTokens = 50 + }), + ["roots"] = InputRequest.ForRootsList(new ListRootsRequestParams()) + }, + requestState: "concurrent-state"); + } + + [Fact] + public async Task Mrtr_ConcurrentThreeInputs_ResolvedSimultaneously() + { + Assert.SkipWhen(UseStreamableHttp && !Stateless, July2026StatefulStreamableHttpSkipReason); + + var messageTracker = ConfigureServer(MrtrConcurrentThree); + await using var app = Builder.Build(); + app.MapMcp(); + await app.StartAsync(TestContext.Current.CancellationToken); + + var elicitCalled = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + var samplingCalled = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + var rootsCalled = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + + await using var client = await ConnectAsync(configureClient: options => + { + options.ProtocolVersion = "2026-07-28"; + options.Handlers.ElicitationHandler = async (request, ct) => + { + elicitCalled.TrySetResult(); + await Task.WhenAll(samplingCalled.Task.WaitAsync(ct), rootsCalled.Task.WaitAsync(ct)); + return new ElicitResult { Action = "accept" }; + }; + options.Handlers.SamplingHandler = async (request, progress, ct) => + { + samplingCalled.TrySetResult(); + await Task.WhenAll(elicitCalled.Task.WaitAsync(ct), rootsCalled.Task.WaitAsync(ct)); + return new CreateMessageResult + { + Content = [new TextContentBlock { Text = "AI-summary" }], + Model = "test-model" + }; + }; + options.Handlers.RootsHandler = async (request, ct) => + { + rootsCalled.TrySetResult(); + await Task.WhenAll(elicitCalled.Task.WaitAsync(ct), samplingCalled.Task.WaitAsync(ct)); + return new ListRootsResult + { + Roots = [new Root { Uri = "file:///workspace", Name = "Workspace" }] + }; + }; + }); + Assert.Equal("2026-07-28", client.NegotiatedProtocolVersion); + + var result = await client.CallToolAsync("mrtr-concurrent-three", + cancellationToken: TestContext.Current.CancellationToken); + + var text = Assert.IsType(Assert.Single(result.Content)).Text; + Assert.Equal("all-ok:elicit=accept,sample=AI-summary,roots=file:///workspace", text); + Assert.True(result.IsError is not true); + messageTracker.AssertMrtrUsed(); + } + + [Fact] + public async Task Mrtr_LoadShedding_RequestStateOnly_CompletesViaMrtr() + { + Assert.SkipWhen(UseStreamableHttp && !Stateless, July2026StatefulStreamableHttpSkipReason); + + var messageTracker = ConfigureServer( + [McpServerTool(Name = "mrtr-loadshed")] (RequestContext context) => + { + if (context.Params!.RequestState is { } state) + { + return $"resumed:{state}"; + } + + // requestState-only InputRequiredException (no inputRequests) + throw new InputRequiredException(requestState: "deferred-work"); + }); + await using var app = Builder.Build(); + app.MapMcp(); + await app.StartAsync(TestContext.Current.CancellationToken); + await using var client = await ConnectExperimentalAsync(); + Assert.Equal("2026-07-28", client.NegotiatedProtocolVersion); + + var result = await client.CallToolAsync("mrtr-loadshed", + cancellationToken: TestContext.Current.CancellationToken); + + var text = Assert.IsType(Assert.Single(result.Content)).Text; + Assert.Equal("resumed:deferred-work", text); + Assert.True(result.IsError is not true); + messageTracker.AssertMrtrUsed(); + } + + [Fact] + public async Task Mrtr_Backcompat_Roots_ResolvedViaLegacyJsonRpc() + { + Assert.SkipWhen(Stateless, "Backcompat requires stateful server for legacy JSON-RPC."); + var messageTracker = ConfigureServer( + [McpServerTool(Name = "mrtr-roots-backcompat")] (RequestContext context) => + { + if (context.Params!.InputResponses is { } responses && + responses.TryGetValue("roots", out var response)) + { + var roots = response.Deserialize(InputResponse.ListRootsResultJsonTypeInfo)?.Roots; + return $"roots-ok:{roots?.FirstOrDefault()?.Name}"; + } + + throw new InputRequiredException( + inputRequests: new Dictionary + { + ["roots"] = InputRequest.ForRootsList(new ListRootsRequestParams()) + }, + requestState: "roots-state"); + }); + await using var app = Builder.Build(); + app.MapMcp(); + await app.StartAsync(TestContext.Current.CancellationToken); + await using var client = await ConnectLegacyAsync(); + Assert.Equal("2025-11-25", client.NegotiatedProtocolVersion); + + var result = await client.CallToolAsync("mrtr-roots-backcompat", + cancellationToken: TestContext.Current.CancellationToken); + + var text = Assert.IsType(Assert.Single(result.Content)).Text; + Assert.Equal("roots-ok:Project", text); + Assert.True(result.IsError is not true); + messageTracker.AssertMrtrNotUsed(); + } + + [Fact] + public async Task Mrtr_Backcompat_MultipleInputRequests_ResolvedViaLegacyJsonRpc() + { + Assert.SkipWhen(Stateless, "Backcompat requires stateful server for legacy JSON-RPC."); + var messageTracker = ConfigureServer( + [McpServerTool(Name = "mrtr-multi-input")] (RequestContext context) => + { + if (context.Params!.InputResponses is { } responses && + responses.TryGetValue("confirm", out var elicitResponse) && + responses.TryGetValue("summarize", out var sampleResponse)) + { + var action = elicitResponse.Deserialize(InputResponse.ElicitResultJsonTypeInfo)?.Action; + var text = sampleResponse.Deserialize(InputResponse.CreateMessageResultJsonTypeInfo)?.Content.OfType().FirstOrDefault()?.Text; + return $"both:{action}:{text}"; + } + + throw new InputRequiredException( + inputRequests: new Dictionary + { + ["confirm"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "Please confirm", + RequestedSchema = new() + }), + ["summarize"] = InputRequest.ForSampling(new CreateMessageRequestParams + { + Messages = [new SamplingMessage + { + Role = Role.User, + Content = [new TextContentBlock { Text = "Summarize" }] + }], + MaxTokens = 100 + }) + }, + requestState: "multi-input-state"); + }); + await using var app = Builder.Build(); + app.MapMcp(); + await app.StartAsync(TestContext.Current.CancellationToken); + await using var client = await ConnectLegacyAsync(); + Assert.Equal("2025-11-25", client.NegotiatedProtocolVersion); + + var result = await client.CallToolAsync("mrtr-multi-input", + cancellationToken: TestContext.Current.CancellationToken); + + var text = Assert.IsType(Assert.Single(result.Content)).Text; + Assert.Equal("both:accept:LLM:Summarize", text); + Assert.True(result.IsError is not true); + messageTracker.AssertMrtrNotUsed(); + } + + [Fact] + public async Task Mrtr_Backcompat_AlwaysIncomplete_FailsAfterMaxRetries() + { + Assert.SkipWhen(Stateless, "Backcompat requires stateful server for legacy JSON-RPC."); + int elicitCallCount = 0; + + ConfigureServer( + [McpServerTool(Name = "mrtr-always-incomplete")] (RequestContext context) => + { + // Always throw - never complete + throw new InputRequiredException( + inputRequests: new Dictionary + { + ["confirm"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "Confirm again", + RequestedSchema = new() + }) + }, + requestState: "infinite"); + }); + await using var app = Builder.Build(); + app.MapMcp(); + await app.StartAsync(TestContext.Current.CancellationToken); + await using var client = await ConnectAsync(configureClient: options => + { + ConfigureMrtrHandlers(options); + options.ProtocolVersion = "2025-11-25"; + var originalHandler = options.Handlers.ElicitationHandler!; + options.Handlers.ElicitationHandler = (request, ct) => + { + Interlocked.Increment(ref elicitCallCount); + return originalHandler(request, ct); + }; + }); + Assert.Equal("2025-11-25", client.NegotiatedProtocolVersion); + + var ex = await Assert.ThrowsAsync(() => + client.CallToolAsync("mrtr-always-incomplete", + cancellationToken: TestContext.Current.CancellationToken).AsTask()); + + Assert.Contains("exceeded", ex.Message, StringComparison.OrdinalIgnoreCase); + Assert.Contains("10", ex.Message); + Assert.Equal(10, elicitCallCount); + } + + [Fact] + public async Task Mrtr_Backcompat_EmptyInputRequests_FailsWithError() + { + Assert.SkipWhen(Stateless, "Backcompat requires stateful server for legacy JSON-RPC."); + ConfigureServer( + [McpServerTool(Name = "mrtr-empty-inputs")] (RequestContext context) => + { + throw new InputRequiredException( + inputRequests: new Dictionary(), + requestState: "empty"); + }); + await using var app = Builder.Build(); + app.MapMcp(); + await app.StartAsync(TestContext.Current.CancellationToken); + await using var client = await ConnectLegacyAsync(); + Assert.Equal("2025-11-25", client.NegotiatedProtocolVersion); + + var ex = await Assert.ThrowsAsync(() => + client.CallToolAsync("mrtr-empty-inputs", + cancellationToken: TestContext.Current.CancellationToken).AsTask()); + + Assert.Contains("without input requests", ex.Message, StringComparison.OrdinalIgnoreCase); + Assert.Equal(McpErrorCode.InternalError, ex.ErrorCode); + } + + [Fact] + public async Task Mrtr_Backcompat_ClientHandlerThrows_PropagatesError() + { + Assert.SkipWhen(Stateless, "Backcompat requires stateful server for legacy JSON-RPC."); + + ConfigureServer(MrtrElicit); + await using var app = Builder.Build(); + app.MapMcp(); + await app.StartAsync(TestContext.Current.CancellationToken); + await using var client = await ConnectAsync(configureClient: options => + { + ConfigureMrtrHandlers(options); + options.ProtocolVersion = "2025-11-25"; + options.Handlers.ElicitationHandler = (request, ct) => + { + throw new InvalidOperationException("Client-side elicitation failure"); + }; + }); + Assert.Equal("2025-11-25", client.NegotiatedProtocolVersion); + + // Handler exception propagates through the backcompat JSON-RPC round-trip. + // The original exception message gets wrapped in "Request failed (remote)" during backcompat. + var ex = await Assert.ThrowsAsync(() => + client.CallToolAsync("mrtr-elicit", + cancellationToken: TestContext.Current.CancellationToken).AsTask()); + Assert.Equal(McpErrorCode.InternalError, ex.ErrorCode); + } +} diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/MapMcpTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/MapMcpTests.cs index 678b27022..ef6832101 100644 --- a/tests/ModelContextProtocol.AspNetCore.Tests/MapMcpTests.cs +++ b/tests/ModelContextProtocol.AspNetCore.Tests/MapMcpTests.cs @@ -14,7 +14,7 @@ namespace ModelContextProtocol.AspNetCore.Tests; -public abstract class MapMcpTests(ITestOutputHelper testOutputHelper) : KestrelInMemoryTest(testOutputHelper) +public abstract partial class MapMcpTests(ITestOutputHelper testOutputHelper) : KestrelInMemoryTest(testOutputHelper) { protected abstract bool UseStreamableHttp { get; } protected abstract bool Stateless { get; } @@ -27,9 +27,8 @@ protected virtual void ConfigureStateless(HttpServerTransportOptions options) protected async Task ConnectAsync( string? path = null, HttpClientTransportOptions? transportOptions = null, - McpClientOptions? clientOptions = null) + Action? configureClient = null) { - // Default behavior when no options are provided path ??= UseStreamableHttp ? "/" : "/sse"; await using var transport = new HttpClientTransport(transportOptions ?? new HttpClientTransportOptions @@ -38,6 +37,8 @@ protected async Task ConnectAsync( TransportMode = UseStreamableHttp ? HttpTransportMode.StreamableHttp : HttpTransportMode.Sse, }, HttpClient, LoggerFactory); + var clientOptions = new McpClientOptions(); + configureClient?.Invoke(clientOptions); return await McpClient.CreateAsync(transport, clientOptions, LoggerFactory, TestContext.Current.CancellationToken); } @@ -110,7 +111,10 @@ public async Task Messages_FromNewUser_AreRejected() await app.StartAsync(TestContext.Current.CancellationToken); - var httpRequestException = await Assert.ThrowsAsync(() => ConnectAsync()); + // Session-scoped user validation across requests is a legacy stateful-session behavior. Starting with the + // 2026-07-28 protocol revision, Streamable HTTP no longer supports sessions. Pin to the latest stable version to keep covering it. + var httpRequestException = await Assert.ThrowsAsync( + () => ConnectAsync(configureClient: options => options.ProtocolVersion = "2025-11-25")); Assert.Equal(HttpStatusCode.Forbidden, httpRequestException.StatusCode); } @@ -156,29 +160,28 @@ public async Task Sampling_DoesNotCloseStreamPrematurely() await app.StartAsync(TestContext.Current.CancellationToken); var sampleCount = 0; - var clientOptions = new McpClientOptions() + await using var mcpClient = await ConnectAsync(configureClient: options => { - Handlers = new() + // Server->client sampling over the open response stream is a stateful-session behavior. + // Starting with the 2026-07-28 protocol revision, Streamable HTTP no longer supports sessions, so the implicit-MRTR suspend path + // doesn't apply over HTTP (this sampling path is covered by the stdio MRTR tests). Pin legacy. + options.ProtocolVersion = "2025-11-25"; + options.Handlers.SamplingHandler = async (parameters, _, _) => { - SamplingHandler = async (parameters, _, _) => - { - Assert.NotNull(parameters?.Messages); - var message = Assert.Single(parameters.Messages); - Assert.Equal(Role.User, message.Role); - Assert.Equal("Test prompt for sampling", Assert.IsType(Assert.Single(message.Content)).Text); + Assert.NotNull(parameters?.Messages); + var message = Assert.Single(parameters.Messages); + Assert.Equal(Role.User, message.Role); + Assert.Equal("Test prompt for sampling", Assert.IsType(Assert.Single(message.Content)).Text); - sampleCount++; - return new CreateMessageResult - { - Model = "test-model", - Role = Role.Assistant, - Content = [new TextContentBlock { Text = "Sampling response from client" }], - }; - } - } - }; - - await using var mcpClient = await ConnectAsync(clientOptions: clientOptions); + sampleCount++; + return new CreateMessageResult + { + Model = "test-model", + Role = Role.Assistant, + Content = [new TextContentBlock { Text = "Sampling response from client" }], + }; + }; + }); var result = await mcpClient.CallToolAsync("sampling-tool", new Dictionary { @@ -323,7 +326,13 @@ await client.CallToolAsync("echo_with_user_name", new Dictionary { ["message"] = "hi" }, cancellationToken: TestContext.Current.CancellationToken); - Assert.Contains(RequestMethods.Initialize, observedMethods); + // The client now defaults to the 2026-07-28 protocol revision, whose handshake is server/discover + // rather than the legacy initialize request. On the stateful Streamable HTTP fixture the + // request is refused, so the client downgrades to the legacy initialize. + var expectedHandshakeMethod = UseStreamableHttp && !Stateless + ? RequestMethods.Initialize + : RequestMethods.ServerDiscover; + Assert.Contains(expectedHandshakeMethod, observedMethods); Assert.Contains(RequestMethods.ToolsList, observedMethods); Assert.Contains(RequestMethods.ToolsCall, observedMethods); } @@ -375,7 +384,14 @@ public async Task OutgoingFilter_SeesResponsesAndRequests() }, }; - await using var client = await ConnectAsync(clientOptions: clientOptions); + await using var client = await ConnectAsync(configureClient: opts => + { + // Server-originated sampling requests and the initialize response are legacy stateful + // behaviors; the 2026-07-28 protocol revision routes sampling through MRTR and drops initialize. + opts.ProtocolVersion = "2025-11-25"; + opts.Capabilities = clientOptions.Capabilities; + opts.Handlers = clientOptions.Handlers; + }); await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); await client.CallToolAsync("echo_claims_principal", @@ -385,10 +401,12 @@ await client.CallToolAsync("sampling-tool", new Dictionary { ["prompt"] = "Hello" }, cancellationToken: TestContext.Current.CancellationToken); - Assert.Contains("initialize-response", observedMessageTypes); - Assert.Contains("tools-list-response", observedMessageTypes); - Assert.Contains("tool-call-response", observedMessageTypes); - Assert.Contains($"request:{RequestMethods.SamplingCreateMessage}", observedMessageTypes); + // Exact counts catch regressions where the outgoing filter pipeline gets applied more than once + // per outbound message (e.g., SendRequestAsync double-wrapping SendToRelatedTransportAsync). + Assert.Equal(1, observedMessageTypes.Count(m => m == "initialize-response")); + Assert.Equal(1, observedMessageTypes.Count(m => m == "tools-list-response")); + Assert.Equal(2, observedMessageTypes.Count(m => m == "tool-call-response")); // one per CallToolAsync + Assert.Equal(2, observedMessageTypes.Count(m => m == $"request:{RequestMethods.SamplingCreateMessage}")); // sampling-tool makes two SampleAsync calls } [Fact] @@ -496,6 +514,7 @@ public async Task OutgoingFilter_CanSendAdditionalMessages() Assert.Equal("injected", extraMessage); } + private ClaimsPrincipal CreateUser(string name) => new(new ClaimsIdentity( [new Claim("name", name), new Claim(ClaimTypes.NameIdentifier, name)], @@ -566,4 +585,5 @@ public static async Task LongRunningOperation( return $"Operation completed after {durationMs}ms"; } } + } diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/ModelContextProtocol.AspNetCore.Tests.csproj b/tests/ModelContextProtocol.AspNetCore.Tests/ModelContextProtocol.AspNetCore.Tests.csproj index 384e8fcdd..781aa7178 100644 --- a/tests/ModelContextProtocol.AspNetCore.Tests/ModelContextProtocol.AspNetCore.Tests.csproj +++ b/tests/ModelContextProtocol.AspNetCore.Tests/ModelContextProtocol.AspNetCore.Tests.csproj @@ -1,4 +1,4 @@ - + net10.0;net9.0;net8.0 @@ -7,6 +7,8 @@ false true ModelContextProtocol.AspNetCore.Tests + + $(NoWarn);MCP9006 @@ -23,6 +25,8 @@ + + @@ -56,6 +60,7 @@ + diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/MrtrProtocolTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/MrtrProtocolTests.cs new file mode 100644 index 000000000..df5d4bd03 --- /dev/null +++ b/tests/ModelContextProtocol.AspNetCore.Tests/MrtrProtocolTests.cs @@ -0,0 +1,504 @@ +using Microsoft.AspNetCore.Builder; +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.AspNetCore.Tests.Utils; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.Net; +using System.Net.ServerSentEvents; +using System.Text; +using System.Text.Json; +using System.Text.Json.Nodes; +using System.Text.Json.Serialization.Metadata; + +namespace ModelContextProtocol.AspNetCore.Tests; + +/// +/// Protocol-level tests for Multi Round-Trip Requests (MRTR) over the 2026-07-28 protocol revision. +/// Under that revision (SEP-2575 + SEP-2567) Streamable HTTP no longer supports sessions, so these tests +/// drive the default server with raw +/// JSON-RPC requests (no initialize, no Mcp-Session-Id) and verify the explicit +/// MRTR structure, retry with inputResponses, and error handling. +/// Stateful-session MRTR behaviors (implicit handler suspension, disposal cancellation) are covered +/// over stdio by MrtrHandlerLifecycleTests, and unknown-session rejection by +/// StreamableHttpServerConformanceTests.PostRequest_IsNotFound_WithUnrecognizedSessionId. +/// +public class MrtrProtocolTests(ITestOutputHelper outputHelper) : KestrelInMemoryTest(outputHelper), IAsyncDisposable +{ + + private WebApplication? _app; + + private async Task StartAsync() + { + Builder.Services.AddMcpServer(options => + { + options.ServerInfo = new Implementation + { + Name = nameof(MrtrProtocolTests), + Version = "1", + }; + }).WithTools([ + McpServerTool.Create( + static string (McpServer _) => throw new McpProtocolException("Tool validation failed", McpErrorCode.InvalidParams), + new McpServerToolCreateOptions + { + Name = "throwing-tool", + Description = "A tool that throws immediately" + }), + McpServerTool.Create( + static CallToolResult (RequestContext context) => + { + // Mirrors ConformanceServer.Tools.IncompleteResultTools.ToolWithTamperedState: + // R1 (no requestState) issues a requestState; R2 with a tampered requestState + // surfaces a JSON-RPC error rather than a complete result or a re-prompt. + if (context.Params!.RequestState is { } state) + { + if (state != "valid-request-state-token") + { + throw new McpProtocolException( + "requestState failed integrity verification.", McpErrorCode.InvalidParams); + } + + return new CallToolResult { Content = [new TextContentBlock { Text = "state-ok" }] }; + } + + throw new InputRequiredException( + new Dictionary + { + ["confirm"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "Please confirm", + RequestedSchema = new ElicitRequestParams.RequestSchema + { + Properties = new Dictionary + { + ["ok"] = new ElicitRequestParams.BooleanSchema(), + }, + Required = ["ok"], + }, + }), + }, + requestState: "valid-request-state-token"); + }, + new McpServerToolCreateOptions + { + Name = "tampered-state-tool", + Description = "Rejects a tampered requestState with a JSON-RPC error" + }), + McpServerTool.Create( + static CallToolResult (RequestContext context) => + { + // Mirrors ConformanceServer.Tools.IncompleteResultTools.ToolWithCapabilityCheck: + // emit inputRequests only for capabilities declared on the per-request _meta envelope. + var caps = context.JsonRpcRequest.Context?.ClientCapabilities; + var inputRequests = new Dictionary(); + + if (caps?.Sampling is not null) + { + inputRequests["capital_question"] = InputRequest.ForSampling(new CreateMessageRequestParams + { + Messages = + [ + new SamplingMessage + { + Role = Role.User, + Content = [new TextContentBlock { Text = "What is the capital of France?" }], + }, + ], + MaxTokens = 100, + }); + } + + if (caps?.Elicitation is not null) + { + inputRequests["user_name"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "What is your name?", + RequestedSchema = new ElicitRequestParams.RequestSchema + { + Properties = new Dictionary + { + ["name"] = new ElicitRequestParams.StringSchema(), + }, + Required = ["name"], + }, + }); + } + + if (inputRequests.Count == 0) + { + return new CallToolResult { Content = [new TextContentBlock { Text = "no-caps" }] }; + } + + throw new InputRequiredException(inputRequests); + }, + new McpServerToolCreateOptions + { + Name = "capability-check-tool", + Description = "Gates inputRequests on the per-request _meta clientCapabilities envelope" + }), + ]).WithHttpTransport(); + + _app = Builder.Build(); + _app.MapMcp(); + await _app.StartAsync(TestContext.Current.CancellationToken); + + // Drive the server with raw requests: every request carries the 2026-07-28 protocol + // MCP-Protocol-Version header and (via PostJsonRpcAsync) the SEP-2243 Mcp-Method/Mcp-Name + // headers. No initialize handshake and no Mcp-Session-Id. + HttpClient.DefaultRequestHeaders.Accept.Add(new("application/json")); + HttpClient.DefaultRequestHeaders.Accept.Add(new("text/event-stream")); + HttpClient.DefaultRequestHeaders.Add("MCP-Protocol-Version", McpProtocolVersions.July2026ProtocolVersion); + } + + public async ValueTask DisposeAsync() + { + if (_app is not null) + { + await _app.DisposeAsync(); + } + base.Dispose(); + } + + [Fact] + public async Task ToolThatThrows_ReturnsJsonRpcError_NotIncompleteResult() + { + await StartAsync(); + + var response = await PostJsonRpcAsync(CallTool("throwing-tool")); + + // Should be a JSON-RPC error, not an InputRequiredResult + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + + var sseData = Assert.Single(await ReadSseAsync(response.Content).ToListAsync(TestContext.Current.CancellationToken)); + var message = JsonSerializer.Deserialize(sseData, McpJsonUtilities.DefaultOptions); + var error = Assert.IsType(message); + Assert.Equal((int)McpErrorCode.InvalidParams, error.Error.Code); + Assert.Contains("Tool validation failed", error.Error.Message); + } + + [Fact] + public async Task TamperedRequestState_ReturnsJsonRpcError() + { + await StartAsync(); + + // Round 1: no requestState -> InputRequiredResult carrying the issued requestState. + using var r1 = await PostJsonRpcAsync(CallTool("tampered-state-tool")); + var r1Response = await AssertSingleSseResponseAsync(r1); + var r1Result = Assert.IsType(r1Response.Result); + Assert.Equal("input_required", r1Result["resultType"]?.GetValue()); + + var requestState = r1Result["requestState"]!.GetValue(); + var inputKey = r1Result["inputRequests"]!.AsObject().First().Key; + + // Round 2: tamper the requestState the way the conformance harness does and retry. + // The tool MUST reject it with a JSON-RPC error (not a complete result, not a re-prompt). + var inputResponse = InputResponse.FromElicitResult(new ElicitResult { Action = "accept" }); + var retryParams = new JsonObject + { + ["name"] = "tampered-state-tool", + ["arguments"] = new JsonObject(), + ["requestState"] = requestState + "-TAMPERED", + ["inputResponses"] = new JsonObject + { + [inputKey] = JsonSerializer.SerializeToNode(inputResponse, McpJsonUtilities.DefaultOptions.GetTypeInfo(typeof(InputResponse))) + }, + }; + + using var r2 = await PostJsonRpcAsync(Request("tools/call", retryParams.ToJsonString())); + Assert.Equal(HttpStatusCode.OK, r2.StatusCode); + + var sseData = Assert.Single(await ReadSseAsync(r2.Content).ToListAsync(TestContext.Current.CancellationToken)); + var message = JsonSerializer.Deserialize(sseData, McpJsonUtilities.DefaultOptions); + var error = Assert.IsType(message); + Assert.Equal((int)McpErrorCode.InvalidParams, error.Error.Code); + } + + [Fact] + public async Task CapabilityCheck_OnlyEmitsInputRequestsForDeclaredCapabilities() + { + await StartAsync(); + + // Per SEP-2575 the client declares capabilities per request in + // _meta['io.modelcontextprotocol/clientCapabilities']. Declare ONLY sampling: the tool + // must emit a sampling/createMessage inputRequest but no elicitation/create. + var callParams = new JsonObject + { + ["name"] = "capability-check-tool", + ["arguments"] = new JsonObject(), + ["_meta"] = new JsonObject + { + ["io.modelcontextprotocol/clientCapabilities"] = new JsonObject + { + ["sampling"] = new JsonObject(), + }, + }, + }; + + using var response = await PostJsonRpcAsync(Request("tools/call", callParams.ToJsonString())); + var rpcResponse = await AssertSingleSseResponseAsync(response); + var resultObj = Assert.IsType(rpcResponse.Result); + Assert.Equal("input_required", resultObj["resultType"]?.GetValue()); + + var inputRequests = resultObj["inputRequests"]!.AsObject(); + Assert.Contains(inputRequests, kvp => kvp.Value!["method"]?.GetValue() == "sampling/createMessage"); + Assert.DoesNotContain(inputRequests, kvp => kvp.Value!["method"]?.GetValue() == "elicitation/create"); + } + + /// + /// Regression test for a CI hang where the server-side MRTR backcompat resolver routed its + /// outgoing roots/list request through the session-level transport, which silently + /// dropped the message when the client's GET stream had not been established yet. The + /// outgoing request must instead go through the POST's response stream (the request's + /// ) so it + /// reaches the client without depending on the GET stream at all. + /// + /// This test deliberately never opens a GET stream - it only POSTs the initialize, the + /// initialized notification, the tools/call, and the roots/list response. If the + /// server falls back to _transport.SendMessageAsync, the test times out instead of + /// reading the expected roots/list SSE event off the tools/call POST response. + /// + [Fact] + public async Task BackcompatResolver_SendsServerRequestOverPostStream_WithoutGetStream() + { + // Configure a server that does NOT pin 2026-07-28 so it can negotiate the current + // initialize-handshake protocol. The backcompat resolver path only runs when the + // negotiated version is not 2026-07-28. + Builder.Services.AddMcpServer(options => + { + options.ServerInfo = new Implementation + { + Name = nameof(MrtrProtocolTests), + Version = "1", + }; + }).WithTools([ + McpServerTool.Create( + static string (RequestContext context) => + { + if (context.Params!.InputResponses is { } responses && + responses.TryGetValue("roots", out var response)) + { + var roots = response.Deserialize(InputResponse.ListRootsResultJsonTypeInfo)?.Roots; + return $"roots-ok:{roots?.FirstOrDefault()?.Name}"; + } + + throw new InputRequiredException( + inputRequests: new Dictionary + { + ["roots"] = InputRequest.ForRootsList(new ListRootsRequestParams()) + }, + requestState: "roots-state"); + }, + new McpServerToolCreateOptions + { + Name = "backcompat-roots-tool", + Description = "Throws InputRequiredException so the server's backcompat resolver issues a roots/list", + }), + ]).WithHttpTransport(options => options.SessionMode = HttpServerSessionMode.Stateful); + + _app = Builder.Build(); + _app.MapMcp(); + await _app.StartAsync(TestContext.Current.CancellationToken); + + HttpClient.DefaultRequestHeaders.Accept.Add(new("application/json")); + HttpClient.DefaultRequestHeaders.Accept.Add(new("text/event-stream")); + + // Initialize with the current initialize-handshake protocol so the server's backcompat resolver runs. + var initJson = """ + {"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-11-25","capabilities":{"roots":{}},"clientInfo":{"name":"BackcompatTestClient","version":"1.0.0"}}} + """; + + string sessionId; + using (var initResponse = await PostJsonRpcAsync(initJson)) + { + var initRpcResponse = await AssertSingleSseResponseAsync(initResponse); + Assert.NotNull(initRpcResponse.Result); + Assert.Equal("2025-11-25", initRpcResponse.Result["protocolVersion"]?.GetValue()); + + sessionId = Assert.Single(initResponse.Headers.GetValues("mcp-session-id")); + } + + HttpClient.DefaultRequestHeaders.Remove("mcp-session-id"); + HttpClient.DefaultRequestHeaders.Add("mcp-session-id", sessionId); + HttpClient.DefaultRequestHeaders.Remove("MCP-Protocol-Version"); + HttpClient.DefaultRequestHeaders.Add("MCP-Protocol-Version", "2025-11-25"); + + // Send the initialized notification. + using (var initializedResponse = await PostJsonRpcAsync( + """{"jsonrpc":"2.0","method":"notifications/initialized"}""")) + { + Assert.True(initializedResponse.IsSuccessStatusCode); + } + + _lastRequestId = 1; + + // POST the tools/call and start reading the response SSE stream. We deliberately do NOT + // open a GET stream - the server-to-client roots/list must be delivered on this POST's + // response. Use HttpCompletionOption.ResponseHeadersRead so the POST returns as soon as + // the response headers arrive instead of waiting for the SSE stream to close. + var callRequest = new HttpRequestMessage(HttpMethod.Post, (string?)null) + { + Content = JsonContent(CallTool("backcompat-roots-tool", includePerRequestMetadata: false)), + }; + callRequest.Content.Headers.Add("Mcp-Method", "tools/call"); + callRequest.Content.Headers.Add("Mcp-Name", "backcompat-roots-tool"); + + using var callResponse = await HttpClient.SendAsync( + callRequest, + HttpCompletionOption.ResponseHeadersRead, + TestContext.Current.CancellationToken); + + Assert.Equal(HttpStatusCode.OK, callResponse.StatusCode); + Assert.Equal("text/event-stream", callResponse.Content.Headers.ContentType?.MediaType); + + var sseEvents = ReadSseAsync(callResponse.Content) + .GetAsyncEnumerator(TestContext.Current.CancellationToken); + + try + { + // First SSE event on this POST should be the server-initiated roots/list request. + Assert.True(await sseEvents.MoveNextAsync(), + "Server did not send a roots/list request on the tools/call POST response stream. " + + "If this hangs/times out, the MRTR backcompat resolver is routing the outgoing request " + + "through the session-level transport instead of the POST's RelatedTransport."); + + var rootsRequestNode = JsonNode.Parse(sseEvents.Current) as JsonObject; + Assert.NotNull(rootsRequestNode); + Assert.Equal("roots/list", rootsRequestNode["method"]?.GetValue()); + var rootsRequestId = rootsRequestNode["id"]; + Assert.NotNull(rootsRequestId); + + // POST the roots/list response on a separate connection. The server's pending + // RequestRootsAsync await will complete and the backcompat resolver will retry the tool. + var rootsIdLiteral = rootsRequestId.ToJsonString(); + var rootsResponseJson = + "{\"jsonrpc\":\"2.0\",\"id\":" + rootsIdLiteral + + ",\"result\":{\"roots\":[{\"uri\":\"file:///workspace\",\"name\":\"Workspace\"}]}}"; + using (var rootsResponseHttp = await PostJsonRpcAsync(rootsResponseJson)) + { + Assert.True(rootsResponseHttp.IsSuccessStatusCode); + } + + // Next SSE event on the original POST should be the final tools/call response. + Assert.True(await sseEvents.MoveNextAsync(), "Server did not return the final tools/call response."); + var finalResponse = JsonSerializer.Deserialize(sseEvents.Current, GetJsonTypeInfo()); + Assert.NotNull(finalResponse); + Assert.NotNull(finalResponse.Result); + + var content = finalResponse.Result["content"]?.AsArray(); + Assert.NotNull(content); + var firstContent = Assert.Single(content); + Assert.Equal("roots-ok:Workspace", firstContent?["text"]?.GetValue()); + } + finally + { + await sseEvents.DisposeAsync(); + } + } + + // --- Helpers --- + + private static StringContent JsonContent(string json) => new(json, Encoding.UTF8, "application/json"); + private static JsonTypeInfo GetJsonTypeInfo() => (JsonTypeInfo)McpJsonUtilities.DefaultOptions.GetTypeInfo(typeof(T)); + + private static async IAsyncEnumerable ReadSseAsync(HttpContent responseContent) + { + var responseStream = await responseContent.ReadAsStreamAsync(TestContext.Current.CancellationToken); + await foreach (var sseItem in SseParser.Create(responseStream).EnumerateAsync(TestContext.Current.CancellationToken)) + { + Assert.Equal("message", sseItem.EventType); + yield return sseItem.Data; + } + } + + private static async Task AssertSingleSseResponseAsync(HttpResponseMessage response) + { + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + Assert.Equal("text/event-stream", response.Content.Headers.ContentType?.MediaType); + + var sseItem = Assert.Single(await ReadSseAsync(response.Content).ToListAsync(TestContext.Current.CancellationToken)); + var jsonRpcResponse = JsonSerializer.Deserialize(sseItem, GetJsonTypeInfo()); + + Assert.NotNull(jsonRpcResponse); + return jsonRpcResponse; + } + + private Task PostJsonRpcAsync(string json) + { + var content = JsonContent(json); + + // 2026-07-28 requires Mcp-Method and (for tools/call) Mcp-Name headers per SEP-2243. + // Parse the body to derive them and attach to this request only. + var bodyNode = JsonNode.Parse(json); + if (bodyNode is JsonObject obj) + { + if (obj["method"]?.GetValue() is { } method) + { + content.Headers.Add("Mcp-Method", method); + + if (obj["params"] is JsonObject paramsObj) + { + string? mcpName = method switch + { + "tools/call" or "prompts/get" => paramsObj["name"]?.GetValue(), + "resources/read" => paramsObj["uri"]?.GetValue(), + _ => null, + }; + if (mcpName is not null) + { + content.Headers.Add("Mcp-Name", mcpName); + } + } + } + } + + return HttpClient.PostAsync("", content, TestContext.Current.CancellationToken); + } + + private long _lastRequestId = 1; + + private string Request(string method, string parameters = "{}", bool includePerRequestMetadata = true) + { + var id = Interlocked.Increment(ref _lastRequestId); + var paramsObj = JsonNode.Parse(parameters) as JsonObject ?? new JsonObject(); + if (includePerRequestMetadata) + { + AddJuly2026ProtocolMeta(paramsObj); + } + + var request = new JsonObject + { + ["jsonrpc"] = "2.0", + ["id"] = id, + ["method"] = method, + ["params"] = paramsObj, + }; + + return request.ToJsonString(); + } + + private static void AddJuly2026ProtocolMeta(JsonObject paramsObj) + { + if (paramsObj["_meta"] is not JsonObject meta) + { + meta = []; + paramsObj["_meta"] = meta; + } + + meta[MetaKeys.ProtocolVersion] = McpProtocolVersions.July2026ProtocolVersion; + meta[MetaKeys.ClientInfo] = new JsonObject + { + ["name"] = "MrtrTestClient", + ["version"] = "1.0", + }; + + if (meta[MetaKeys.ClientCapabilities] is not JsonObject) + { + meta[MetaKeys.ClientCapabilities] = new JsonObject(); + } + } + + private string CallTool(string toolName, string arguments = "{}", bool includePerRequestMetadata = true) => + Request("tools/call", $$""" + {"name":"{{toolName}}","arguments":{{arguments}}} + """, includePerRequestMetadata); +} diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/OAuth/AuthEventTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/OAuth/AuthEventTests.cs index 7aafd312e..1866dfe13 100644 --- a/tests/ModelContextProtocol.AspNetCore.Tests/OAuth/AuthEventTests.cs +++ b/tests/ModelContextProtocol.AspNetCore.Tests/OAuth/AuthEventTests.cs @@ -48,7 +48,7 @@ public async Task CanAuthenticate_WithResourceMetadataFromEvent() ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = HandleAuthorizationUrlAsync, + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, }, }, HttpClient, @@ -76,7 +76,7 @@ public async Task CanAuthenticate_WithDynamicClientRegistration_FromEvent() OAuth = new ClientOAuthOptions() { RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = HandleAuthorizationUrlAsync, + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, Scopes = ["mcp:tools"], DynamicClientRegistration = new() { diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/OAuth/AuthTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/OAuth/AuthTests.cs index c4979fb10..693c77943 100644 --- a/tests/ModelContextProtocol.AspNetCore.Tests/OAuth/AuthTests.cs +++ b/tests/ModelContextProtocol.AspNetCore.Tests/OAuth/AuthTests.cs @@ -11,6 +11,7 @@ using ModelContextProtocol.Client; using ModelContextProtocol.Protocol; using ModelContextProtocol.Server; +using ModelContextProtocol.Tests.Utils; using System.Net; using System.Net.Http.Json; using System.Security.Claims; @@ -41,12 +42,209 @@ public async Task CanAuthenticate() ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, + }, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + } + + [Fact] + public async Task AuthorizationCallbackHandler_ReceivesConfiguredRedirectUri() + { + await using var app = await StartMcpServerAsync(); + + var redirectUri = new Uri("http://localhost:1179/callback"); + AuthorizationCallbackContext? callbackContext = null; + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = redirectUri, + AuthorizationCallbackHandler = (context, cancellationToken) => + { + callbackContext = context; + return HandleAuthorizationUrlAsync(context, cancellationToken); + }, + }, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + + Assert.NotNull(callbackContext); + Assert.Equal(redirectUri, callbackContext.RedirectUri); + } + + [Theory] + [InlineData(false, null)] + [InlineData(true, "https://localhost:7029")] + [InlineData(true, "https://attacker.example")] + public async Task AuthorizationRedirectDelegate_ReceivesConfiguredUrisAndSkipsResponseIssuerValidation( + bool authorizationResponseIssParameterSupported, + string? authorizationResponseIssuer) + { + TestOAuthServer.AuthorizationResponseIssParameterSupported = authorizationResponseIssParameterSupported; + TestOAuthServer.AuthorizationResponseIssuer = authorizationResponseIssuer; + await using var app = await StartMcpServerAsync(); + + var redirectUri = new Uri("http://localhost:1179/callback"); + Uri? receivedAuthorizationUri = null; + Uri? receivedRedirectUri = null; + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = redirectUri, +#pragma warning disable MCP9007 // Verify the obsolete callback remains functional during its compatibility window. + AuthorizationRedirectDelegate = (authorizationUri, callbackRedirectUri, cancellationToken) => + { + receivedAuthorizationUri = authorizationUri; + receivedRedirectUri = callbackRedirectUri; + return HandleAuthorizationUrlAsync(authorizationUri, callbackRedirectUri, cancellationToken); + }, +#pragma warning restore MCP9007 + }, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + + Assert.NotNull(receivedAuthorizationUri); + Assert.Equal(redirectUri, receivedRedirectUri); + } + + [Fact] + public async Task AuthorizationRedirectDelegate_DoesNotSkipMetadataIssuerValidation() + { + TestOAuthServer.MetadataIssuerOverride = "https://attacker.example"; + await using var app = await StartMcpServerAsync(); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), +#pragma warning disable MCP9007 // Verify the obsolete callback retains metadata issuer validation. AuthorizationRedirectDelegate = HandleAuthorizationUrlAsync, +#pragma warning restore MCP9007 }, }, HttpClient, LoggerFactory); + var ex = await Assert.ThrowsAsync(() => McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)); + + Assert.Contains("does not match the expected issuer", ex.Message); + } + + [Fact] + public void HttpClientTransport_RejectsBothAuthorizationCallbacks() + { +#pragma warning disable MCP9007 // Verify ambiguous legacy and current callback configuration is rejected. + var options = new ClientOAuthOptions + { + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = (_, _) => Task.FromResult(new()), + AuthorizationRedirectDelegate = (_, _, _) => Task.FromResult("code"), + }; +#pragma warning restore MCP9007 + + var ex = Assert.Throws(() => new HttpClientTransport( + new() + { + Endpoint = new(McpServerUrl), + OAuth = options, + }, + HttpClient, + LoggerFactory)); + + Assert.Contains(nameof(ClientOAuthOptions.AuthorizationCallbackHandler), ex.Message); +#pragma warning disable MCP9007 // The obsolete property name should be included in the diagnostic. + Assert.Contains(nameof(ClientOAuthOptions.AuthorizationRedirectDelegate), ex.Message); +#pragma warning restore MCP9007 + } + + [Fact] + public async Task CanAuthenticate_WhenAuthorizationResponseStateMatches() + { + await using var app = await StartMcpServerAsync(); + + string? requestedState = null; + await using var transport = CreateOAuthTransport((context, cancellationToken) => + { + requestedState = QueryHelpers.ParseQuery(context.AuthorizationUri.Query)["state"]; + return HandleAuthorizationUrlAsync(context, cancellationToken); + }); + await using var client = await McpClient.CreateAsync( transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + + Assert.NotNull(requestedState); + Assert.True(requestedState.Length >= 43); + Assert.Equal(1, TestOAuthServer.AuthorizationCodeTokenRequestCount); + } + + [Fact] + public async Task CannotAuthenticate_WhenAuthorizationResponseStateIsMissing() + { + await using var app = await StartMcpServerAsync(); + await using var transport = CreateOAuthTransport( + (_, _) => Task.FromResult(new() { Code = "unused-code" })); + + var ex = await Assert.ThrowsAsync(() => McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)); + + Assert.Contains("did not include the required state parameter", ex.Message); + Assert.Equal(0, TestOAuthServer.AuthorizationCodeTokenRequestCount); + } + + [Fact] + public async Task CannotAuthenticate_WhenAuthorizationResponseStateMismatches() + { + await using var app = await StartMcpServerAsync(); + await using var transport = CreateOAuthTransport( + (_, _) => Task.FromResult( + new() { Code = "unused-code", State = "unexpected-state" })); + + var ex = await Assert.ThrowsAsync(() => McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)); + + Assert.Contains("state did not match", ex.Message); + Assert.Equal(0, TestOAuthServer.AuthorizationCodeTokenRequestCount); + } + + [Fact] + public async Task AuthorizationRequests_UseUniqueStateValues() + { + await using var app = await StartMcpServerAsync(); + List requestedStates = []; + + for (var i = 0; i < 2; i++) + { + await using var transport = CreateOAuthTransport((context, cancellationToken) => + { + requestedStates.Add(QueryHelpers.ParseQuery(context.AuthorizationUri.Query)["state"].ToString()); + return HandleAuthorizationUrlAsync(context, cancellationToken); + }); + + await using var client = await McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + } + + Assert.Equal(2, requestedStates.Count); + Assert.Equal(2, requestedStates.Distinct(StringComparer.Ordinal).Count()); } [Fact] @@ -78,7 +276,7 @@ public async Task CannotAuthenticate_WithUnregisteredClient() ClientId = "unregistered-demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = HandleAuthorizationUrlAsync, + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, }, }, HttpClient, LoggerFactory); @@ -98,7 +296,7 @@ public async Task CanAuthenticate_WithDynamicClientRegistration() OAuth = new ClientOAuthOptions() { RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = HandleAuthorizationUrlAsync, + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, DynamicClientRegistration = new() { ClientName = "Test MCP Client", @@ -109,6 +307,33 @@ public async Task CanAuthenticate_WithDynamicClientRegistration() await using var client = await McpClient.CreateAsync( transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + + Assert.Equal("native", TestOAuthServer.LastApplicationType); + } + + [Fact] + public async Task DynamicClientRegistration_UsesExplicitApplicationType() + { + await using var app = await StartMcpServerAsync(); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new ClientOAuthOptions() + { + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, + DynamicClientRegistration = new() + { + ApplicationType = "web", + }, + }, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + + Assert.Equal("web", TestOAuthServer.LastApplicationType); } [Fact] @@ -122,8 +347,91 @@ public async Task CanAuthenticate_WithClientMetadataDocument() OAuth = new ClientOAuthOptions() { RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = HandleAuthorizationUrlAsync, - ClientMetadataDocumentUri = new Uri(ClientMetadataDocumentUrl) + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, + ClientMetadataDocumentUri = new Uri(ClientMetadataDocumentUrl), + DynamicClientRegistration = new() + { + ApplicationType = "web", + }, + }, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + } + + [Fact] + public async Task CannotAuthenticate_WhenMetadataOmitsPkceMethods() + { + TestOAuthServer.CodeChallengeMethodsSupported = null; + await using var app = await StartMcpServerAsync(); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, + }, + }, HttpClient, LoggerFactory); + + await Assert.ThrowsAsync(() => McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)); + + // No discovery endpoint advertises PKCE, so metadata discovery is exhausted. The precise PKCE reason + // is logged as each endpoint is skipped. + Assert.Contains( + MockLoggerProvider.LogMessages, + m => m.Exception?.Message.Contains("code_challenge_methods_supported") == true); + } + + [Fact] + public async Task CannotAuthenticate_WhenMetadataLacksS256PkceMethod() + { + TestOAuthServer.CodeChallengeMethodsSupported = ["plain"]; + await using var app = await StartMcpServerAsync(); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, + }, + }, HttpClient, LoggerFactory); + + await Assert.ThrowsAsync(() => McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)); + + Assert.Contains( + MockLoggerProvider.LogMessages, + m => m.Exception?.Message.Contains("required PKCE method 'S256'") == true); + } + + [Fact] + public async Task CanAuthenticate_WhenFirstMetadataEndpointOmitsPkce_ButAnotherAdvertisesIt() + { + // The OAuth 2.0 authorization server metadata endpoint is tried before the OpenID Connect one. + // Simulate a server where only the OpenID Connect document advertises PKCE support, and verify the + // client falls through to it rather than failing on the first PKCE-less document. + TestOAuthServer.MetadataPathsWithoutPkceSupport.Add("/.well-known/oauth-authorization-server"); + await using var app = await StartMcpServerAsync(); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, }, }, HttpClient, LoggerFactory); @@ -147,7 +455,7 @@ public async Task UsesDynamicClientRegistration_WhenCimdNotSupported() OAuth = new ClientOAuthOptions() { RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = HandleAuthorizationUrlAsync, + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, ClientMetadataDocumentUri = new Uri("http://invalid-cimd.example.com"), DynamicClientRegistration = new() { @@ -176,8 +484,12 @@ public async Task DoesNotUseClientMetadataDocument_WhenClientIdIsSpecified() ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = HandleAuthorizationUrlAsync, + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, ClientMetadataDocumentUri = new Uri("http://invalid-cimd.example.com"), + DynamicClientRegistration = new() + { + ApplicationType = "web", + }, }, }, HttpClient, LoggerFactory); @@ -198,7 +510,7 @@ public async Task CannotAuthenticate_WithInvalidClientMetadataDocument(string ur OAuth = new ClientOAuthOptions() { RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = HandleAuthorizationUrlAsync, + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, ClientMetadataDocumentUri = new Uri(uri), }, }, HttpClient, LoggerFactory); @@ -263,7 +575,7 @@ public async Task CanAuthenticate_WithTokenRefresh() ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = HandleAuthorizationUrlAsync, + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, }, }, HttpClient, LoggerFactory); @@ -290,10 +602,10 @@ public async Task CanAuthenticate_WithExtraParams() ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = (uri, redirect, ct) => + AuthorizationCallbackHandler = (context, ct) => { - lastAuthorizationUri = uri; - return HandleAuthorizationUrlAsync(uri, redirect, ct); + lastAuthorizationUri = context.AuthorizationUri; + return HandleAuthorizationUrlAsync(context, ct); }, AdditionalAuthorizationParameters = new Dictionary { @@ -309,8 +621,10 @@ public async Task CanAuthenticate_WithExtraParams() Assert.Contains("custom_param=custom_value", lastAuthorizationUri?.Query); } - [Fact] - public async Task CannotOverrideExistingParameters_WithExtraParams() + [Theory] + [InlineData("redirect_uri")] + [InlineData("state")] + public async Task CannotOverrideExistingParameters_WithExtraParams(string parameterName) { await using var app = await StartMcpServerAsync(); @@ -322,10 +636,10 @@ public async Task CannotOverrideExistingParameters_WithExtraParams() ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = HandleAuthorizationUrlAsync, + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, AdditionalAuthorizationParameters = new Dictionary { - ["redirect_uri"] = "custom_value", + [parameterName] = "custom_value", } }, }, HttpClient, LoggerFactory); @@ -347,7 +661,7 @@ public async Task CanAuthenticate_WithoutResourceInWwwAuthenticateHeader() ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = HandleAuthorizationUrlAsync, + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, }, }, HttpClient, LoggerFactory); @@ -369,7 +683,7 @@ public async Task CanAuthenticate_WithoutResourceInWwwAuthenticateHeader_WithPat ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = HandleAuthorizationUrlAsync, + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, }, }, HttpClient, LoggerFactory); @@ -397,11 +711,11 @@ public async Task AuthorizationFlow_UsesScopeFromProtectedResourceMetadata() ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = (uri, redirect, ct) => + AuthorizationCallbackHandler = (context, ct) => { - var query = QueryHelpers.ParseQuery(uri.Query); + var query = QueryHelpers.ParseQuery(context.AuthorizationUri.Query); requestedScope = query["scope"].ToString(); - return HandleAuthorizationUrlAsync(uri, redirect, ct); + return HandleAuthorizationUrlAsync(context, ct); }, }, }, HttpClient, LoggerFactory); @@ -409,7 +723,9 @@ public async Task AuthorizationFlow_UsesScopeFromProtectedResourceMetadata() await using var client = await McpClient.CreateAsync( transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); - Assert.Equal("mcp:tools files:read", requestedScope); + var requestedScopeSet = new HashSet(requestedScope!.Split(' ')); + Assert.Contains("mcp:tools", requestedScopeSet); + Assert.Contains("files:read", requestedScopeSet); } [Fact] @@ -448,11 +764,11 @@ public async Task AuthorizationFlow_UsesScopeFromChallengeHeader() ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = (uri, redirect, ct) => + AuthorizationCallbackHandler = (context, ct) => { - var query = QueryHelpers.ParseQuery(uri.Query); + var query = QueryHelpers.ParseQuery(context.AuthorizationUri.Query); requestedScope = query["scope"].ToString(); - return HandleAuthorizationUrlAsync(uri, redirect, ct); + return HandleAuthorizationUrlAsync(context, ct); }, }, }, HttpClient, LoggerFactory); @@ -473,9 +789,13 @@ public async Task AuthorizationFlow_UsesScopeFromForbiddenHeader() McpServerTool.Create([McpServerTool(Name = "admin-tool")] (ClaimsPrincipal user) => { - // Tool now just checks if user has the required scopes - // If they don't, it shouldn't get here due to middleware - Assert.True(user.HasClaim("scope", adminScopes), "User should have admin scopes when tool executes"); + // Verify the user's scope claim contains all required admin scopes. + // With scope accumulation (SEP-2350), the token scope will be the union + // of previously granted and newly challenged scopes. + var scopeClaim = user.FindFirst("scope")?.Value ?? ""; + var scopeSet = new HashSet(scopeClaim.Split(' ')); + Assert.Contains("admin:read", scopeSet); + Assert.Contains("admin:write", scopeSet); return "Admin tool executed."; }), ]); @@ -510,9 +830,11 @@ public async Task AuthorizationFlow_UsesScopeFromForbiddenHeader() if (toolCallParams?.Name == "admin-tool") { - // Check if user has required scopes + // Check if user has required scopes (scope claim contains all admin scopes) var user = context.User; - if (!user.HasClaim("scope", adminScopes)) + var scopeClaim = user.FindFirst("scope")?.Value ?? ""; + var scopeSet = new HashSet(scopeClaim.Split(' ')); + if (!scopeSet.Contains("admin:read") || !scopeSet.Contains("admin:write")) { // User lacks required scopes, return 403 before MapMcp processes the request context.Response.StatusCode = StatusCodes.Status403Forbidden; @@ -537,11 +859,11 @@ public async Task AuthorizationFlow_UsesScopeFromForbiddenHeader() ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = (uri, redirect, ct) => + AuthorizationCallbackHandler = (context, ct) => { - var query = QueryHelpers.ParseQuery(uri.Query); + var query = QueryHelpers.ParseQuery(context.AuthorizationUri.Query); requestedScope = query["scope"].ToString(); - return HandleAuthorizationUrlAsync(uri, redirect, ct); + return HandleAuthorizationUrlAsync(context, ct); }, }, }, HttpClient, LoggerFactory); @@ -554,57 +876,85 @@ public async Task AuthorizationFlow_UsesScopeFromForbiddenHeader() var adminResult = await client.CallToolAsync("admin-tool", cancellationToken: TestContext.Current.CancellationToken); Assert.Equal("Admin tool executed.", adminResult.Content[0].ToString()); - Assert.Equal(adminScopes, requestedScope); + // SEP-2350: Verify that the step-up authorization request includes the union + // of previously requested scopes (mcp:tools) and newly challenged scopes (admin:read admin:write). + var requestedScopeSet = new HashSet(requestedScope!.Split(' ')); + Assert.Contains("mcp:tools", requestedScopeSet); + Assert.Contains("admin:read", requestedScopeSet); + Assert.Contains("admin:write", requestedScopeSet); } [Fact] - public async Task AuthorizationFails_WhenResourceMetadataPortDiffers() + public async Task AuthorizationFlow_AccumulatesScopesAcrossMultipleStepUps() { - Builder.Services.Configure(McpAuthenticationDefaults.AuthenticationScheme, options => - { - options.ResourceMetadata!.Resource = "http://localhost:5999"; - }); + // SEP-2350: Verify scope accumulation across multiple step-up authorization challenges. + // First call requires "files:read", second call requires "files:write". + // The second authorization request should include both "mcp:tools files:read files:write". - await using var app = await StartMcpServerAsync(); + Builder.Services.AddMcpServer() + .WithTools([ + McpServerTool.Create([McpServerTool(Name = "read-tool")] + (ClaimsPrincipal user) => + { + return "Read tool executed."; + }), + McpServerTool.Create([McpServerTool(Name = "write-tool")] + (ClaimsPrincipal user) => + { + return "Write tool executed."; + }), + ]); - await using var transport = new HttpClientTransport(new() + List requestedScopes = []; + + await using var app = await StartMcpServerAsync(configureMiddleware: app => { - Endpoint = new(McpServerUrl), - OAuth = new() + app.Use(async (context, next) => { - ClientId = "demo-client", - ClientSecret = "demo-secret", - RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = HandleAuthorizationUrlAsync, - }, - }, HttpClient, LoggerFactory); + if (context.Request.Method == HttpMethods.Post && context.Request.Path == "/") + { + context.Request.EnableBuffering(); - await Assert.ThrowsAsync(() => McpClient.CreateAsync( - transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)); - } + var message = await JsonSerializer.DeserializeAsync( + context.Request.Body, + McpJsonUtilities.DefaultOptions.GetTypeInfo(typeof(JsonRpcMessage)), + context.RequestAborted) as JsonRpcMessage; - [Fact] - public async Task CannotAuthenticate_WhenProtectedResourceMetadataMissingResource() - { - TestOAuthServer.ExpectResource = false; + context.Request.Body.Position = 0; - Builder.Services.Configure(McpAuthenticationDefaults.AuthenticationScheme, options => - { - options.Events.OnResourceMetadataRequest = async context => - { - context.HandleResponse(); + if (message is JsonRpcRequest request && request.Method == "tools/call") + { + var toolCallParams = JsonSerializer.Deserialize( + request.Params, + McpJsonUtilities.DefaultOptions.GetTypeInfo(typeof(CallToolRequestParams))) as CallToolRequestParams; - var metadata = new ProtectedResourceMetadata - { - AuthorizationServers = { OAuthServerUrl }, - ScopesSupported = ["mcp:tools"], - }; + var user = context.User; + var scopeClaim = user.FindFirst("scope")?.Value ?? ""; + var scopeSet = new HashSet(scopeClaim.Split(' ')); - await Results.Json(metadata, McpJsonUtilities.DefaultOptions).ExecuteAsync(context.HttpContext); - }; - }); + if (toolCallParams?.Name == "read-tool" && !scopeSet.Contains("files:read")) + { + context.Response.StatusCode = StatusCodes.Status403Forbidden; + context.Response.Headers.WWWAuthenticate = $"Bearer error=\"insufficient_scope\", resource_metadata=\"{McpServerUrl}/.well-known/oauth-protected-resource\", scope=\"files:read\""; + await context.Response.StartAsync(context.RequestAborted); + await context.Response.Body.FlushAsync(context.RequestAborted); + return; + } - await using var app = await StartMcpServerAsync(); + if (toolCallParams?.Name == "write-tool" && !scopeSet.Contains("files:write")) + { + context.Response.StatusCode = StatusCodes.Status403Forbidden; + context.Response.Headers.WWWAuthenticate = $"Bearer error=\"insufficient_scope\", resource_metadata=\"{McpServerUrl}/.well-known/oauth-protected-resource\", scope=\"files:write\""; + await context.Response.StartAsync(context.RequestAborted); + await context.Response.Body.FlushAsync(context.RequestAborted); + return; + } + } + } + + await next(context); + }); + }); await using var transport = new HttpClientTransport(new() { @@ -614,25 +964,113 @@ public async Task CannotAuthenticate_WhenProtectedResourceMetadataMissingResourc ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = HandleAuthorizationUrlAsync, + AuthorizationCallbackHandler = (context, ct) => + { + var query = QueryHelpers.ParseQuery(context.AuthorizationUri.Query); + requestedScopes.Add(query["scope"].ToString()); + return HandleAuthorizationUrlAsync(context, ct); + }, }, }, HttpClient, LoggerFactory); - var ex = await Assert.ThrowsAsync(() => McpClient.CreateAsync( - transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)); + await using var client = await McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); - Assert.Contains("Resource URI in metadata", ex.Message); + // Initial auth gets "mcp:tools" from protected resource metadata + Assert.Single(requestedScopes); + Assert.Equal("mcp:tools", requestedScopes[0]); + + // First step-up: read-tool requires "files:read" + var readResult = await client.CallToolAsync("read-tool", cancellationToken: TestContext.Current.CancellationToken); + Assert.Equal("Read tool executed.", readResult.Content[0].ToString()); + Assert.Equal(2, requestedScopes.Count); + var secondScopeSet = new HashSet(requestedScopes[1]!.Split(' ')); + Assert.Contains("mcp:tools", secondScopeSet); + Assert.Contains("files:read", secondScopeSet); + + // Second step-up: write-tool requires "files:write" + var writeResult = await client.CallToolAsync("write-tool", cancellationToken: TestContext.Current.CancellationToken); + Assert.Equal("Write tool executed.", writeResult.Content[0].ToString()); + Assert.Equal(3, requestedScopes.Count); + var thirdScopeSet = new HashSet(requestedScopes[2]!.Split(' ')); + Assert.Contains("mcp:tools", thirdScopeSet); + Assert.Contains("files:read", thirdScopeSet); + Assert.Contains("files:write", thirdScopeSet); } [Fact] - public async Task CanAuthenticate_WithAuthorizationServerPathInsertionMetadata() + public async Task AuthorizationFlow_ConcurrentStepUps_ReuseSteppedUpToken_WhenChallengeAddsNoNewScope() { - Builder.Services.Configure(McpAuthenticationDefaults.AuthenticationScheme, options => + // Two concurrent calls to the same tool both receive the same insufficient_scope challenge + // before either has stepped up. They serialize on the provider's token acquisition lock: the + // first runs the step-up and caches the broader token, and the second must reuse that token + // instead of failing as a "repeated" challenge. Only one interactive step-up should run. + TestOAuthServer.AuthorizationResponseIssParameterSupported = true; + TestOAuthServer.AuthorizationResponseIssuer = OAuthServerUrl; + + Builder.Services.AddMcpServer() + .WithTools([ + McpServerTool.Create([McpServerTool(Name = "read-tool")] + (ClaimsPrincipal user) => + { + return "Read tool executed."; + }), + ]); + + List requestedScopes = []; + var scopeLock = new object(); + + // Release both initial challenges only after both concurrent calls have reached the server, so + // the second caller is guaranteed to be waiting on the token lock while the first steps up. + var bothChallengesReached = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + int challengesReached = 0; + + await using var app = await StartMcpServerAsync(configureMiddleware: app => { - options.ResourceMetadata!.AuthorizationServers = [$"{OAuthServerUrl}/tenant1"]; - }); + app.Use(async (context, next) => + { + if (context.Request.Method == HttpMethods.Post && context.Request.Path == "/") + { + context.Request.EnableBuffering(); - await using var app = await StartMcpServerAsync(); + var message = await JsonSerializer.DeserializeAsync( + context.Request.Body, + McpJsonUtilities.DefaultOptions.GetTypeInfo(typeof(JsonRpcMessage)), + context.RequestAborted) as JsonRpcMessage; + + context.Request.Body.Position = 0; + + if (message is JsonRpcRequest request && request.Method == "tools/call") + { + var toolCallParams = JsonSerializer.Deserialize( + request.Params, + McpJsonUtilities.DefaultOptions.GetTypeInfo(typeof(CallToolRequestParams))) as CallToolRequestParams; + + var user = context.User; + var scopeClaim = user.FindFirst("scope")?.Value ?? ""; + var scopeSet = new HashSet(scopeClaim.Split(' ')); + + if (toolCallParams?.Name == "read-tool" && !scopeSet.Contains("files:read")) + { + if (Interlocked.Increment(ref challengesReached) == 2) + { + bothChallengesReached.TrySetResult(); + } + + await bothChallengesReached.Task.WaitAsync(TestConstants.DefaultTimeout, context.RequestAborted); + + context.Response.StatusCode = StatusCodes.Status403Forbidden; + context.Response.Headers.WWWAuthenticate = $"Bearer error=\"insufficient_scope\", resource_metadata=\"{McpServerUrl}/.well-known/oauth-protected-resource\", scope=\"files:read\""; + await context.Response.StartAsync(context.RequestAborted); + await context.Response.Body.FlushAsync(context.RequestAborted); + return; + } + } + } + + await next(context); + }); + }); await using var transport = new HttpClientTransport(new() { @@ -642,30 +1080,95 @@ public async Task CanAuthenticate_WithAuthorizationServerPathInsertionMetadata() ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = HandleAuthorizationUrlAsync, + AuthorizationCallbackHandler = (context, cancellationToken) => + { + var query = QueryHelpers.ParseQuery(context.AuthorizationUri.Query); + lock (scopeLock) + { + requestedScopes.Add(query["scope"].ToString()); + } + return HandleAuthorizationUrlAsync(context, cancellationToken); + }, }, }, HttpClient, LoggerFactory); await using var client = await McpClient.CreateAsync( transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); - var requests = TestOAuthServer.MetadataRequests.ToArray(); - Assert.Contains("/.well-known/oauth-authorization-server/tenant1", requests); + // Initial connect requests "mcp:tools" from protected resource metadata. + Assert.Single(requestedScopes); + Assert.Equal("mcp:tools", requestedScopes[0]); + + var firstCall = client.CallToolAsync("read-tool", cancellationToken: TestContext.Current.CancellationToken).AsTask(); + var secondCall = client.CallToolAsync("read-tool", cancellationToken: TestContext.Current.CancellationToken).AsTask(); + + var results = await Task.WhenAll(firstCall, secondCall); + + Assert.Equal("Read tool executed.", results[0].Content[0].ToString()); + Assert.Equal("Read tool executed.", results[1].Content[0].ToString()); + + // Only one interactive step-up should have run; the second caller reused the token from the first. + Assert.Equal(2, requestedScopes.Count); + var stepUpScopes = new HashSet(requestedScopes[1]!.Split(' ')); + Assert.Contains("mcp:tools", stepUpScopes); + Assert.Contains("files:read", stepUpScopes); } [Fact] - public async Task CanAuthenticate_WithAuthorizationServerPathFallbacks() + public async Task AuthorizationFlow_StopsSteppingUpWhenChallengeAddsNoNewScope() { - const string issuerPath = "/subdir/tenant2"; - TestOAuthServer.DisabledMetadataPaths.Add($"/.well-known/oauth-authorization-server{issuerPath}"); - TestOAuthServer.DisabledMetadataPaths.Add($"/.well-known/openid-configuration{issuerPath}"); + // SEP-2350: A misconfigured server repeats the same insufficient_scope challenge even after the + // client has already requested that scope. Re-running interactive authorization cannot make + // progress, so the client must treat it as a permanent failure rather than prompting the user + // again on every call to the same resource and operation. - Builder.Services.Configure(McpAuthenticationDefaults.AuthenticationScheme, options => + Builder.Services.AddMcpServer() + .WithTools([ + McpServerTool.Create([McpServerTool(Name = "deny-tool")] + (ClaimsPrincipal user) => + { + return "Deny tool executed."; + }), + ]); + + List requestedScopes = []; + + await using var app = await StartMcpServerAsync(configureMiddleware: app => { - options.ResourceMetadata!.AuthorizationServers = [$"{OAuthServerUrl}{issuerPath}"]; - }); + app.Use(async (context, next) => + { + if (context.Request.Method == HttpMethods.Post && context.Request.Path == "/") + { + context.Request.EnableBuffering(); - await using var app = await StartMcpServerAsync(); + var message = await JsonSerializer.DeserializeAsync( + context.Request.Body, + McpJsonUtilities.DefaultOptions.GetTypeInfo(typeof(JsonRpcMessage)), + context.RequestAborted) as JsonRpcMessage; + + context.Request.Body.Position = 0; + + if (message is JsonRpcRequest request && request.Method == "tools/call") + { + var toolCallParams = JsonSerializer.Deserialize( + request.Params, + McpJsonUtilities.DefaultOptions.GetTypeInfo(typeof(CallToolRequestParams))) as CallToolRequestParams; + + // Always reject "deny-tool" with the same challenge, regardless of the token's scopes. + if (toolCallParams?.Name == "deny-tool") + { + context.Response.StatusCode = StatusCodes.Status403Forbidden; + context.Response.Headers.WWWAuthenticate = $"Bearer error=\"insufficient_scope\", resource_metadata=\"{McpServerUrl}/.well-known/oauth-protected-resource\", scope=\"files:read\""; + await context.Response.StartAsync(context.RequestAborted); + await context.Response.Body.FlushAsync(context.RequestAborted); + return; + } + } + } + + await next(context); + }); + }); await using var transport = new HttpClientTransport(new() { @@ -675,206 +1178,208 @@ public async Task CanAuthenticate_WithAuthorizationServerPathFallbacks() ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = HandleAuthorizationUrlAsync, + AuthorizationCallbackHandler = (context, ct) => + { + var query = QueryHelpers.ParseQuery(context.AuthorizationUri.Query); + requestedScopes.Add(query["scope"].ToString()); + return HandleAuthorizationUrlAsync(context, ct); + }, }, }, HttpClient, LoggerFactory); await using var client = await McpClient.CreateAsync( transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); - Assert.Equal( - [ - $"/.well-known/oauth-authorization-server{issuerPath}", - $"/.well-known/openid-configuration{issuerPath}", - $"{issuerPath}/.well-known/openid-configuration", - "/.well-known/openid-configuration", - ], - TestOAuthServer.MetadataRequests); + // Initial auth gets "mcp:tools" from protected resource metadata. + Assert.Single(requestedScopes); + + // First call introduces a new scope ("files:read"), so exactly one step-up authorization occurs. + await Assert.ThrowsAnyAsync( + () => client.CallToolAsync("deny-tool", cancellationToken: TestContext.Current.CancellationToken).AsTask()); + Assert.Equal(2, requestedScopes.Count); + + // Second call repeats the same challenge with no new scope. The client must NOT prompt again; + // it surfaces a permanent authorization failure instead of re-running interactive authorization. + var ex = await Assert.ThrowsAnyAsync( + () => client.CallToolAsync("deny-tool", cancellationToken: TestContext.Current.CancellationToken).AsTask()); + Assert.Contains("added no scope beyond those already requested", ex.ToString()); + + // No additional authorization prompt was triggered by the second call. + Assert.Equal(2, requestedScopes.Count); } [Fact] - public async Task CanAuthenticate_WithResourceMetadataPathFallbacks() + public async Task AuthorizationFlow_AllowsOneStepUpEvenWhenChallengeAddsNoNewScope() { - const string resourcePath = "/mcp"; - List wellKnownRequests = []; + // SEP-2350 (strict reading): A step-up authorization is always allowed at least once, even when + // the challenged scope was already requested during the initial authorization. Only a *repeated* + // challenge that still adds no new scope is treated as permanent. Here the server always rejects + // "deny-tool" with the same "mcp:tools" scope that the client already requested on initial connect. - Builder.Services.Configure(options => options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme); - await using var app = Builder.Build(); + Builder.Services.AddMcpServer() + .WithTools([ + McpServerTool.Create([McpServerTool(Name = "deny-tool")] + (ClaimsPrincipal user) => + { + return "Deny tool executed."; + }), + ]); - var metadata = new ProtectedResourceMetadata - { - Resource = $"{McpServerUrl}{resourcePath}", - AuthorizationServers = { OAuthServerUrl }, - }; + List requestedScopes = []; - app.Use(async (context, next) => + await using var app = await StartMcpServerAsync(configureMiddleware: app => { - if (context.Request.Path.StartsWithSegments("/.well-known/oauth-protected-resource", out var remaining)) + app.Use(async (context, next) => { - wellKnownRequests.Add(context.Request.Path); - if (remaining.HasValue) + if (context.Request.Method == HttpMethods.Post && context.Request.Path == "/") { - context.Response.StatusCode = StatusCodes.Status404NotFound; - return; - } - } + context.Request.EnableBuffering(); - await next(); - }); + var message = await JsonSerializer.DeserializeAsync( + context.Request.Body, + McpJsonUtilities.DefaultOptions.GetTypeInfo(typeof(JsonRpcMessage)), + context.RequestAborted) as JsonRpcMessage; - app.UseAuthentication(); - app.UseAuthorization(); + context.Request.Body.Position = 0; - app.MapMcp(resourcePath).RequireAuthorization(); + if (message is JsonRpcRequest request && request.Method == "tools/call") + { + var toolCallParams = JsonSerializer.Deserialize( + request.Params, + McpJsonUtilities.DefaultOptions.GetTypeInfo(typeof(CallToolRequestParams))) as CallToolRequestParams; - await app.StartAsync(TestContext.Current.CancellationToken); + // Always reject "deny-tool" challenging "mcp:tools", which the client already + // requested on initial connect, so the challenge never introduces a new scope. + if (toolCallParams?.Name == "deny-tool") + { + context.Response.StatusCode = StatusCodes.Status403Forbidden; + context.Response.Headers.WWWAuthenticate = $"Bearer error=\"insufficient_scope\", resource_metadata=\"{McpServerUrl}/.well-known/oauth-protected-resource\", scope=\"mcp:tools\""; + await context.Response.StartAsync(context.RequestAborted); + await context.Response.Body.FlushAsync(context.RequestAborted); + return; + } + } + } - var endpoint = new Uri(new Uri(McpServerUrl), resourcePath); + await next(context); + }); + }); await using var transport = new HttpClientTransport(new() { - Endpoint = endpoint, + Endpoint = new(McpServerUrl), OAuth = new() { ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = HandleAuthorizationUrlAsync, + AuthorizationCallbackHandler = (context, ct) => + { + var query = QueryHelpers.ParseQuery(context.AuthorizationUri.Query); + requestedScopes.Add(query["scope"].ToString()); + return HandleAuthorizationUrlAsync(context, ct); + }, }, }, HttpClient, LoggerFactory); await using var client = await McpClient.CreateAsync( transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); - Assert.Equal( - [ - $"/.well-known/oauth-protected-resource{resourcePath}", - "/.well-known/oauth-protected-resource" - ], - wellKnownRequests); + // Initial auth already requests "mcp:tools" from protected resource metadata. + Assert.Single(requestedScopes); + Assert.Equal("mcp:tools", requestedScopes[0]); + + // First call: even though the challenged scope is not new, one step-up attempt is still allowed, + // so a second authorization request is made. + await Assert.ThrowsAnyAsync( + () => client.CallToolAsync("deny-tool", cancellationToken: TestContext.Current.CancellationToken).AsTask()); + Assert.Equal(2, requestedScopes.Count); + + // Second call: the step-up has already been attempted and the challenge still adds no new scope, + // so the client surfaces a permanent failure without prompting again. + var ex = await Assert.ThrowsAnyAsync( + () => client.CallToolAsync("deny-tool", cancellationToken: TestContext.Current.CancellationToken).AsTask()); + Assert.Contains("added no scope beyond those already requested", ex.ToString()); + Assert.Equal(2, requestedScopes.Count); } [Fact] - public async Task CannotAuthenticate_WhenResourceMetadataResourceIsNonRootParentPath() + public async Task AuthorizationFails_WhenResourceMetadataPortDiffers() { - const string configuredResourcePath = "/mcp"; - const string requestedResourcePath = "/mcp/tools"; - - // Remove resource_metadata from the WWW-Authenticate header, because we should only fall back at all (even to root) when it's missing. - // - // If the protected resource metadata was retrieved from a URL returned by the protected resource via the WWW-Authenticate resource_metadata parameter, - // then the resource value returned MUST be identical to the URL that the client used to make the request to the resource server. - // If these values are not identical, the data contained in the response MUST NOT be used. - // - // https://datatracker.ietf.org/doc/html/rfc9728/#section-3.3 - // - // CannotAuthenticate_WhenWwwAuthenticateResourceMetadataIsRootPath validates we won't fall back to root in this case. - // CanAuthenticate_WithResourceMetadataPathFallbacks validates we will fall back to root when resource_metadata is missing. - Builder.Services.Configure(options => options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme); Builder.Services.Configure(McpAuthenticationDefaults.AuthenticationScheme, options => { - options.ResourceMetadata = new ProtectedResourceMetadata - { - Resource = $"{McpServerUrl}{configuredResourcePath}", - AuthorizationServers = { OAuthServerUrl }, - }; + options.ResourceMetadata!.Resource = "http://localhost:5999"; }); - await using var app = Builder.Build(); - - app.MapMcp(requestedResourcePath).RequireAuthorization(); - - await app.StartAsync(TestContext.Current.CancellationToken); + await using var app = await StartMcpServerAsync(); await using var transport = new HttpClientTransport(new() { - Endpoint = new Uri($"{McpServerUrl}{requestedResourcePath}"), + Endpoint = new(McpServerUrl), OAuth = new() { ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = HandleAuthorizationUrlAsync, + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, }, }, HttpClient, LoggerFactory); - var ex = await Assert.ThrowsAsync(async () => - { - await McpClient.CreateAsync( - transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); - }); - - Assert.Contains("does not match", ex.Message); + await Assert.ThrowsAsync(() => McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)); } [Fact] - public async Task CannotAuthenticate_WhenWwwAuthenticateResourceMetadataIsRootPath() + public async Task CannotAuthenticate_WhenProtectedResourceMetadataMissingResource() { - const string requestedResourcePath = "/mcp/tools"; + TestOAuthServer.ExpectResource = false; Builder.Services.Configure(McpAuthenticationDefaults.AuthenticationScheme, options => { - options.ResourceMetadata = new ProtectedResourceMetadata + options.Events.OnResourceMetadataRequest = async context => { - Resource = McpServerUrl, - AuthorizationServers = { OAuthServerUrl }, - }; - }); + context.HandleResponse(); - await using var app = Builder.Build(); + var metadata = new ProtectedResourceMetadata + { + AuthorizationServers = { OAuthServerUrl }, + ScopesSupported = ["mcp:tools"], + }; - app.MapMcp(requestedResourcePath).RequireAuthorization(); + await Results.Json(metadata, McpJsonUtilities.DefaultOptions).ExecuteAsync(context.HttpContext); + }; + }); - await app.StartAsync(TestContext.Current.CancellationToken); + await using var app = await StartMcpServerAsync(); await using var transport = new HttpClientTransport(new() { - Endpoint = new Uri($"{McpServerUrl}{requestedResourcePath}"), + Endpoint = new(McpServerUrl), OAuth = new() { ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = HandleAuthorizationUrlAsync, + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, }, }, HttpClient, LoggerFactory); - var ex = await Assert.ThrowsAsync(async () => - { - await McpClient.CreateAsync( - transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); - }); + var ex = await Assert.ThrowsAsync(() => McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)); - Assert.Contains("does not match", ex.Message); + Assert.Contains("Resource URI in metadata", ex.Message); } [Fact] - public async Task ResourceMetadata_DoesNotAddTrailingSlash() + public async Task CanAuthenticate_WithAuthorizationServerPathInsertionMetadata() { - // This test verifies that automatically derived resource URIs don't have trailing slashes - // and that the client doesn't add them during authentication - - // Don't explicitly set Resource - let it be derived from the request - await using var app = await StartMcpServerAsync(); - - // First, manually check the PRM document doesn't contain a trailing slash - using var metadataResponse = await HttpClient.GetAsync( - "/.well-known/oauth-protected-resource", - TestContext.Current.CancellationToken - ); - - Assert.Equal(HttpStatusCode.OK, metadataResponse.StatusCode); - - var metadata = await metadataResponse.Content.ReadFromJsonAsync( - McpJsonUtilities.DefaultOptions, - TestContext.Current.CancellationToken - ); + Builder.Services.Configure(McpAuthenticationDefaults.AuthenticationScheme, options => + { + options.ResourceMetadata!.AuthorizationServers = [$"{OAuthServerUrl}/tenant1"]; + }); - Assert.NotNull(metadata); - Assert.Equal("http://localhost:5000", metadata.Resource); - Assert.DoesNotMatch(@"/$", metadata.Resource); // No trailing slash + await using var app = await StartMcpServerAsync(); - // Then authenticate with the client - this will use the derived resource URI await using var transport = new HttpClientTransport(new() { Endpoint = new(McpServerUrl), @@ -883,174 +1388,686 @@ public async Task ResourceMetadata_DoesNotAddTrailingSlash() ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = HandleAuthorizationUrlAsync, + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, }, }, HttpClient, LoggerFactory); - // This should succeed - the client should not add a trailing slash - // If the client incorrectly added a trailing slash, ValidResources would reject it await using var client = await McpClient.CreateAsync( transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + + var requests = TestOAuthServer.MetadataRequests.ToArray(); + Assert.Contains("/.well-known/oauth-authorization-server/tenant1", requests); } [Fact] - public void CloneResourceMetadataClonesAllProperties() + public async Task CanAuthenticate_WithAuthorizationServerPathFallbacks() { - var propertyNames = typeof(ProtectedResourceMetadata).GetProperties().Select(property => property.Name).ToList(); + const string issuerPath = "/subdir/tenant2"; + TestOAuthServer.DisabledMetadataPaths.Add($"/.well-known/oauth-authorization-server{issuerPath}"); + TestOAuthServer.DisabledMetadataPaths.Add($"/.well-known/openid-configuration{issuerPath}"); - // Set metadata properties to non-default values to verify they're copied. - var metadata = new ProtectedResourceMetadata + Builder.Services.Configure(McpAuthenticationDefaults.AuthenticationScheme, options => { - Resource = "https://example.com/resource", - AuthorizationServers = ["https://auth1.example.com", "https://auth2.example.com"], - BearerMethodsSupported = ["header", "body", "query"], - ScopesSupported = ["read", "write", "admin"], - JwksUri = "https://example.com/.well-known/jwks.json", - ResourceSigningAlgValuesSupported = ["RS256", "ES256"], - ResourceName = "Test Resource", - ResourceDocumentation = "https://docs.example.com", - ResourcePolicyUri = "https://example.com/policy", - ResourceTosUri = "https://example.com/terms", - TlsClientCertificateBoundAccessTokens = true, - AuthorizationDetailsTypesSupported = ["payment_initiation", "account_information"], - DpopSigningAlgValuesSupported = ["RS256", "PS256"], - DpopBoundAccessTokensRequired = true - }; + options.ResourceMetadata!.AuthorizationServers = [$"{OAuthServerUrl}{issuerPath}"]; + }); - var clonedMetadata = metadata.Clone(); + await using var app = await StartMcpServerAsync(); - // Ensure the cloned metadata is not the same instance - Assert.NotSame(metadata, clonedMetadata); + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, + }, + }, HttpClient, LoggerFactory); - // Verify Resource property - Assert.Equal(metadata.Resource, clonedMetadata.Resource); - Assert.True(propertyNames.Remove(nameof(metadata.Resource))); + await using var client = await McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); - // Verify AuthorizationServers list is cloned and contains the same values - Assert.NotSame(metadata.AuthorizationServers, clonedMetadata.AuthorizationServers); - Assert.Equal(metadata.AuthorizationServers, clonedMetadata.AuthorizationServers); - Assert.True(propertyNames.Remove(nameof(metadata.AuthorizationServers))); + Assert.Equal( + [ + $"/.well-known/oauth-authorization-server{issuerPath}", + $"/.well-known/openid-configuration{issuerPath}", + $"{issuerPath}/.well-known/openid-configuration", + "/.well-known/openid-configuration", + ], + TestOAuthServer.MetadataRequests); + } - // Verify BearerMethodsSupported list is cloned and contains the same values - Assert.NotSame(metadata.BearerMethodsSupported, clonedMetadata.BearerMethodsSupported); - Assert.Equal(metadata.BearerMethodsSupported, clonedMetadata.BearerMethodsSupported); - Assert.True(propertyNames.Remove(nameof(metadata.BearerMethodsSupported))); + [Fact] + public async Task CannotAuthenticate_WhenAuthorizationServerMetadataIssuerMismatches() + { + TestOAuthServer.MetadataIssuerOverride = "https://attacker.example"; - // Verify ScopesSupported list is cloned and contains the same values - Assert.NotSame(metadata.ScopesSupported, clonedMetadata.ScopesSupported); - Assert.Equal(metadata.ScopesSupported, clonedMetadata.ScopesSupported); - Assert.True(propertyNames.Remove(nameof(metadata.ScopesSupported))); + await using var app = await StartMcpServerAsync(); + await using var transport = CreateOAuthTransport(); - // Verify JwksUri property - Assert.Equal(metadata.JwksUri, clonedMetadata.JwksUri); - Assert.True(propertyNames.Remove(nameof(metadata.JwksUri))); + var ex = await Assert.ThrowsAsync(() => McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)); - // Verify ResourceSigningAlgValuesSupported list is cloned (nullable list) - Assert.NotSame(metadata.ResourceSigningAlgValuesSupported, clonedMetadata.ResourceSigningAlgValuesSupported); - Assert.Equal(metadata.ResourceSigningAlgValuesSupported, clonedMetadata.ResourceSigningAlgValuesSupported); - Assert.True(propertyNames.Remove(nameof(metadata.ResourceSigningAlgValuesSupported))); + Assert.Contains("does not match the expected issuer", ex.Message); + Assert.Single(TestOAuthServer.MetadataRequests); + } - // Verify ResourceName property - Assert.Equal(metadata.ResourceName, clonedMetadata.ResourceName); - Assert.True(propertyNames.Remove(nameof(metadata.ResourceName))); + [Fact] + public async Task CannotAuthenticate_WhenAuthorizationServerMetadataOmitsIssuer() + { + TestOAuthServer.IncludeIssuerInMetadata = false; - // Verify ResourceDocumentation property - Assert.Equal(metadata.ResourceDocumentation, clonedMetadata.ResourceDocumentation); - Assert.True(propertyNames.Remove(nameof(metadata.ResourceDocumentation))); + await using var app = await StartMcpServerAsync(); + await using var transport = CreateOAuthTransport(); - // Verify ResourcePolicyUri property - Assert.Equal(metadata.ResourcePolicyUri, clonedMetadata.ResourcePolicyUri); - Assert.True(propertyNames.Remove(nameof(metadata.ResourcePolicyUri))); + var ex = await Assert.ThrowsAsync(() => McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)); - // Verify ResourceTosUri property - Assert.Equal(metadata.ResourceTosUri, clonedMetadata.ResourceTosUri); - Assert.True(propertyNames.Remove(nameof(metadata.ResourceTosUri))); + Assert.Contains("did not provide the required issuer", ex.Message); + Assert.Single(TestOAuthServer.MetadataRequests); + } - // Verify TlsClientCertificateBoundAccessTokens property - Assert.Equal(metadata.TlsClientCertificateBoundAccessTokens, clonedMetadata.TlsClientCertificateBoundAccessTokens); - Assert.True(propertyNames.Remove(nameof(metadata.TlsClientCertificateBoundAccessTokens))); + [Fact] + public async Task CanAuthenticate_WhenAuthorizationResponseIssuerMatches() + { + TestOAuthServer.AuthorizationResponseIssParameterSupported = true; + TestOAuthServer.AuthorizationResponseIssuer = OAuthServerUrl; - // Verify AuthorizationDetailsTypesSupported list is cloned (nullable list) - Assert.NotSame(metadata.AuthorizationDetailsTypesSupported, clonedMetadata.AuthorizationDetailsTypesSupported); - Assert.Equal(metadata.AuthorizationDetailsTypesSupported, clonedMetadata.AuthorizationDetailsTypesSupported); - Assert.True(propertyNames.Remove(nameof(metadata.AuthorizationDetailsTypesSupported))); + await using var app = await StartMcpServerAsync(); + await using var transport = CreateOAuthTransport(); + await using var client = await McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + } - // Verify DpopSigningAlgValuesSupported list is cloned (nullable list) - Assert.NotSame(metadata.DpopSigningAlgValuesSupported, clonedMetadata.DpopSigningAlgValuesSupported); - Assert.Equal(metadata.DpopSigningAlgValuesSupported, clonedMetadata.DpopSigningAlgValuesSupported); - Assert.True(propertyNames.Remove(nameof(metadata.DpopSigningAlgValuesSupported))); + [Theory] + [InlineData(true, "https://attacker.example", "does not match expected issuer")] + [InlineData(true, null, "advertises RFC 9207 iss parameter support but none was received")] + [InlineData(false, "https://attacker.example", "does not match expected issuer")] + public async Task CannotAuthenticate_WhenAuthorizationResponseIssuerIsInvalid( + bool authorizationResponseIssParameterSupported, + string? authorizationResponseIssuer, + string expectedMessage) + { + TestOAuthServer.AuthorizationResponseIssParameterSupported = authorizationResponseIssParameterSupported; + TestOAuthServer.AuthorizationResponseIssuer = authorizationResponseIssuer; - // Verify DpopBoundAccessTokensRequired property - Assert.Equal(metadata.DpopBoundAccessTokensRequired, clonedMetadata.DpopBoundAccessTokensRequired); - Assert.True(propertyNames.Remove(nameof(metadata.DpopBoundAccessTokensRequired))); + await using var app = await StartMcpServerAsync(); + await using var transport = CreateOAuthTransport(); - // Ensure we've checked every property. When new properties get added, we'll have to update this test along with the Clone implementation. - Assert.Empty(propertyNames); + var ex = await Assert.ThrowsAsync(() => McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)); + + Assert.Contains(expectedMessage, ex.Message); } [Fact] - public async Task ResourceMetadata_PreservesExplicitTrailingSlash() + public async Task CanAuthenticate_WithResourceMetadataPathFallbacks() { - // This test verifies that explicitly configured trailing slashes are preserved - const string resourceWithTrailingSlash = "http://localhost:5000/"; - - // Configure ValidResources to accept the trailing slash version for this test - TestOAuthServer.ValidResources = [resourceWithTrailingSlash, "http://localhost:5000/mcp"]; - - Builder.Services.Configure(McpAuthenticationDefaults.AuthenticationScheme, options => + const string resourcePath = "/mcp"; + List wellKnownRequests = []; + + Builder.Services.Configure(options => options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme); + await using var app = Builder.Build(); + + var metadata = new ProtectedResourceMetadata { - options.ResourceMetadata = new ProtectedResourceMetadata + Resource = $"{McpServerUrl}{resourcePath}", + AuthorizationServers = { OAuthServerUrl }, + }; + + app.Use(async (context, next) => + { + if (context.Request.Path.StartsWithSegments("/.well-known/oauth-protected-resource", out var remaining)) { - Resource = resourceWithTrailingSlash, - AuthorizationServers = { OAuthServerUrl }, - ScopesSupported = ["mcp:tools"], - }; - }); + wellKnownRequests.Add(context.Request.Path); + if (remaining.HasValue) + { + context.Response.StatusCode = StatusCodes.Status404NotFound; + return; + } + } - await using var app = await StartMcpServerAsync(); + await next(); + }); - // First, manually check the PRM document contains the trailing slash - using var metadataResponse = await HttpClient.GetAsync( - "/.well-known/oauth-protected-resource", - TestContext.Current.CancellationToken - ); + app.UseAuthentication(); + app.UseAuthorization(); - Assert.Equal(HttpStatusCode.OK, metadataResponse.StatusCode); + app.MapMcp(resourcePath).RequireAuthorization(); - var metadata = await metadataResponse.Content.ReadFromJsonAsync( - McpJsonUtilities.DefaultOptions, - TestContext.Current.CancellationToken - ); + await app.StartAsync(TestContext.Current.CancellationToken); - Assert.NotNull(metadata); - Assert.Equal(resourceWithTrailingSlash, metadata.Resource); - Assert.Matches(@"/$", metadata.Resource); // Has trailing slash + var endpoint = new Uri(new Uri(McpServerUrl), resourcePath); - // Then authenticate with the client await using var transport = new HttpClientTransport(new() { - Endpoint = new(McpServerUrl), + Endpoint = endpoint, OAuth = new() { ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = HandleAuthorizationUrlAsync, + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, }, }, HttpClient, LoggerFactory); - // This should succeed with the explicitly configured trailing slash - // If the client incorrectly trimmed the slash, ValidResources would reject it await using var client = await McpClient.CreateAsync( transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); - } - [Fact] - public async Task CanAuthenticate_WithLegacyServerWithoutProtectedResourceMetadata() + Assert.Equal( + [ + $"/.well-known/oauth-protected-resource{resourcePath}", + "/.well-known/oauth-protected-resource" + ], + wellKnownRequests); + } + + [Fact] + public async Task CannotAuthenticate_WhenResourceMetadataResourceIsNonRootParentPath() + { + const string configuredResourcePath = "/mcp"; + const string requestedResourcePath = "/mcp/tools"; + + // Remove resource_metadata from the WWW-Authenticate header, because we should only fall back at all (even to root) when it's missing. + // + // If the protected resource metadata was retrieved from a URL returned by the protected resource via the WWW-Authenticate resource_metadata parameter, + // then the resource value returned MUST be identical to the URL that the client used to make the request to the resource server. + // If these values are not identical, the data contained in the response MUST NOT be used. + // + // https://datatracker.ietf.org/doc/html/rfc9728/#section-3.3 + // + // CanAuthenticate_WhenWwwAuthenticateResourceMetadataIsRootPath validates that a root-level resource is accepted in this case. + // CanAuthenticate_WithResourceMetadataPathFallbacks validates we will fall back to root when resource_metadata is missing. + Builder.Services.Configure(options => options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme); + Builder.Services.Configure(McpAuthenticationDefaults.AuthenticationScheme, options => + { + options.ResourceMetadata = new ProtectedResourceMetadata + { + Resource = $"{McpServerUrl}{configuredResourcePath}", + AuthorizationServers = { OAuthServerUrl }, + }; + }); + + await using var app = Builder.Build(); + + app.MapMcp(requestedResourcePath).RequireAuthorization(); + + await app.StartAsync(TestContext.Current.CancellationToken); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new Uri($"{McpServerUrl}{requestedResourcePath}"), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, + }, + }, HttpClient, LoggerFactory); + + var ex = await Assert.ThrowsAsync(async () => + { + await McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + }); + + Assert.Contains("does not match", ex.Message); + } + + /// + /// Verifies that OAuth authentication succeeds when the protected resource metadata URI + /// matches the root server URL, even when the actual MCP endpoint is at a subpath. + /// This tests the flexible URI matching behavior where the resource URI can be less specific + /// than the actual endpoint being accessed. + /// + [Fact] + public async Task CanAuthenticate_WhenWwwAuthenticateResourceMetadataIsRootPath() + { + const string requestedResourcePath = "/mcp/tools"; + + Builder.Services.Configure(McpAuthenticationDefaults.AuthenticationScheme, options => + { + options.ResourceMetadata = new ProtectedResourceMetadata + { + Resource = McpServerUrl, + AuthorizationServers = { OAuthServerUrl }, + }; + }); + + await using var app = Builder.Build(); + + app.MapMcp(requestedResourcePath).RequireAuthorization(); + + await app.StartAsync(TestContext.Current.CancellationToken); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new Uri($"{McpServerUrl}{requestedResourcePath}"), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, + }, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + } + + /// + /// Verifies that OAuth authentication fails when the protected resource metadata URI + /// does not match the requested MCP server endpoint. This ensures that clients cannot + /// use OAuth tokens intended for one server to access a different server. + /// + [Fact] + public async Task CannotAuthenticate_WhenResourceMetadataUriDoesNotMatch() + { + const string requestedResourcePath = "/mcp/tools"; + const string differentResourceUri = "http://different-server.example.com"; + + Builder.Services.Configure(McpAuthenticationDefaults.AuthenticationScheme, options => + { + options.ResourceMetadata = new ProtectedResourceMetadata + { + Resource = differentResourceUri, + AuthorizationServers = { OAuthServerUrl }, + }; + }); + + await using var app = Builder.Build(); + + app.MapMcp(requestedResourcePath).RequireAuthorization(); + + await app.StartAsync(TestContext.Current.CancellationToken); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new Uri($"{McpServerUrl}{requestedResourcePath}"), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, + }, + }, HttpClient, LoggerFactory); + + // This should fail because the resource URI doesn't match + var ex = await Assert.ThrowsAsync(() => McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)); + + Assert.Contains("does not match", ex.Message); + } + + /// + /// Verifies that OAuth authentication fails when the protected resource metadata URI is an + /// unrelated path on the same host as the requested endpoint (e.g. resource=.../service-a vs + /// endpoint .../service-b). This ensures the authority-level fallback only accepts an exact match + /// or an authority-only resource, and not arbitrary sibling paths on the same host. + /// + [Fact] + public async Task CannotAuthenticate_WhenResourceMetadataResourceIsDifferentPathOnSameAuthority() + { + const string requestedResourcePath = "/service-b"; + const string differentResourcePath = "/service-a"; + + Builder.Services.Configure(McpAuthenticationDefaults.AuthenticationScheme, options => + { + options.ResourceMetadata = new ProtectedResourceMetadata + { + Resource = $"{McpServerUrl}{differentResourcePath}", + AuthorizationServers = { OAuthServerUrl }, + }; + }); + + await using var app = Builder.Build(); + + app.MapMcp(requestedResourcePath).RequireAuthorization(); + + await app.StartAsync(TestContext.Current.CancellationToken); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new Uri($"{McpServerUrl}{requestedResourcePath}"), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, + }, + }, HttpClient, LoggerFactory); + + // This should fail because the resource URI is a different path on the same host, + // which is neither an exact match nor the authority-only base URL. + var ex = await Assert.ThrowsAsync(() => McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)); + + Assert.Contains("does not match", ex.Message); + } + + [Fact] + public async Task ResourceMetadata_DoesNotAddTrailingSlash() + { + // This test verifies that automatically derived resource URIs don't have trailing slashes + // and that the client doesn't add them during authentication + + // Don't explicitly set Resource - let it be derived from the request + await using var app = await StartMcpServerAsync(); + + // First, manually check the PRM document doesn't contain a trailing slash + using var metadataResponse = await HttpClient.GetAsync( + "/.well-known/oauth-protected-resource", + TestContext.Current.CancellationToken + ); + + Assert.Equal(HttpStatusCode.OK, metadataResponse.StatusCode); + + var metadata = await metadataResponse.Content.ReadFromJsonAsync( + McpJsonUtilities.DefaultOptions, + TestContext.Current.CancellationToken + ); + + Assert.NotNull(metadata); + Assert.Equal("http://localhost:5000", metadata.Resource); + Assert.DoesNotMatch(@"/$", metadata.Resource); // No trailing slash + + // Then authenticate with the client - this will use the derived resource URI + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, + }, + }, HttpClient, LoggerFactory); + + // This should succeed - the client should not add a trailing slash + // If the client incorrectly added a trailing slash, ValidResources would reject it + await using var client = await McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + } + + [Fact] + public void CloneResourceMetadataClonesAllProperties() + { + var propertyNames = typeof(ProtectedResourceMetadata).GetProperties().Select(property => property.Name).ToList(); + + // Set metadata properties to non-default values to verify they're copied. + var metadata = new ProtectedResourceMetadata + { + Resource = "https://example.com/resource", + AuthorizationServers = ["https://auth1.example.com", "https://auth2.example.com"], + BearerMethodsSupported = ["header", "body", "query"], + ScopesSupported = ["read", "write", "admin"], + JwksUri = "https://example.com/.well-known/jwks.json", + ResourceSigningAlgValuesSupported = ["RS256", "ES256"], + ResourceName = "Test Resource", + ResourceDocumentation = "https://docs.example.com", + ResourcePolicyUri = "https://example.com/policy", + ResourceTosUri = "https://example.com/terms", + TlsClientCertificateBoundAccessTokens = true, + AuthorizationDetailsTypesSupported = ["payment_initiation", "account_information"], + DpopSigningAlgValuesSupported = ["RS256", "PS256"], + DpopBoundAccessTokensRequired = true + }; + + var clonedMetadata = metadata.Clone(); + + // Ensure the cloned metadata is not the same instance + Assert.NotSame(metadata, clonedMetadata); + + // Verify Resource property + Assert.Equal(metadata.Resource, clonedMetadata.Resource); + Assert.True(propertyNames.Remove(nameof(metadata.Resource))); + + // Verify AuthorizationServers list is cloned and contains the same values + Assert.NotSame(metadata.AuthorizationServers, clonedMetadata.AuthorizationServers); + Assert.Equal(metadata.AuthorizationServers, clonedMetadata.AuthorizationServers); + Assert.True(propertyNames.Remove(nameof(metadata.AuthorizationServers))); + + // Verify BearerMethodsSupported list is cloned and contains the same values + Assert.NotSame(metadata.BearerMethodsSupported, clonedMetadata.BearerMethodsSupported); + Assert.Equal(metadata.BearerMethodsSupported, clonedMetadata.BearerMethodsSupported); + Assert.True(propertyNames.Remove(nameof(metadata.BearerMethodsSupported))); + + // Verify ScopesSupported list is cloned and contains the same values + Assert.NotSame(metadata.ScopesSupported, clonedMetadata.ScopesSupported); + Assert.Equal(metadata.ScopesSupported, clonedMetadata.ScopesSupported); + Assert.True(propertyNames.Remove(nameof(metadata.ScopesSupported))); + + // Verify JwksUri property + Assert.Equal(metadata.JwksUri, clonedMetadata.JwksUri); + Assert.True(propertyNames.Remove(nameof(metadata.JwksUri))); + + // Verify ResourceSigningAlgValuesSupported list is cloned (nullable list) + Assert.NotSame(metadata.ResourceSigningAlgValuesSupported, clonedMetadata.ResourceSigningAlgValuesSupported); + Assert.Equal(metadata.ResourceSigningAlgValuesSupported, clonedMetadata.ResourceSigningAlgValuesSupported); + Assert.True(propertyNames.Remove(nameof(metadata.ResourceSigningAlgValuesSupported))); + + // Verify ResourceName property + Assert.Equal(metadata.ResourceName, clonedMetadata.ResourceName); + Assert.True(propertyNames.Remove(nameof(metadata.ResourceName))); + + // Verify ResourceDocumentation property + Assert.Equal(metadata.ResourceDocumentation, clonedMetadata.ResourceDocumentation); + Assert.True(propertyNames.Remove(nameof(metadata.ResourceDocumentation))); + + // Verify ResourcePolicyUri property + Assert.Equal(metadata.ResourcePolicyUri, clonedMetadata.ResourcePolicyUri); + Assert.True(propertyNames.Remove(nameof(metadata.ResourcePolicyUri))); + + // Verify ResourceTosUri property + Assert.Equal(metadata.ResourceTosUri, clonedMetadata.ResourceTosUri); + Assert.True(propertyNames.Remove(nameof(metadata.ResourceTosUri))); + + // Verify TlsClientCertificateBoundAccessTokens property + Assert.Equal(metadata.TlsClientCertificateBoundAccessTokens, clonedMetadata.TlsClientCertificateBoundAccessTokens); + Assert.True(propertyNames.Remove(nameof(metadata.TlsClientCertificateBoundAccessTokens))); + + // Verify AuthorizationDetailsTypesSupported list is cloned (nullable list) + Assert.NotSame(metadata.AuthorizationDetailsTypesSupported, clonedMetadata.AuthorizationDetailsTypesSupported); + Assert.Equal(metadata.AuthorizationDetailsTypesSupported, clonedMetadata.AuthorizationDetailsTypesSupported); + Assert.True(propertyNames.Remove(nameof(metadata.AuthorizationDetailsTypesSupported))); + + // Verify DpopSigningAlgValuesSupported list is cloned (nullable list) + Assert.NotSame(metadata.DpopSigningAlgValuesSupported, clonedMetadata.DpopSigningAlgValuesSupported); + Assert.Equal(metadata.DpopSigningAlgValuesSupported, clonedMetadata.DpopSigningAlgValuesSupported); + Assert.True(propertyNames.Remove(nameof(metadata.DpopSigningAlgValuesSupported))); + + // Verify DpopBoundAccessTokensRequired property + Assert.Equal(metadata.DpopBoundAccessTokensRequired, clonedMetadata.DpopBoundAccessTokensRequired); + Assert.True(propertyNames.Remove(nameof(metadata.DpopBoundAccessTokensRequired))); + + // Ensure we've checked every property. When new properties get added, we'll have to update this test along with the Clone implementation. + Assert.Empty(propertyNames); + } + + [Fact] + public async Task ResourceMetadata_PreservesExplicitTrailingSlash() + { + // This test verifies that explicitly configured trailing slashes are preserved + const string resourceWithTrailingSlash = "http://localhost:5000/"; + + // Configure ValidResources to accept the trailing slash version for this test + TestOAuthServer.ValidResources = [resourceWithTrailingSlash, "http://localhost:5000/mcp"]; + + Builder.Services.Configure(McpAuthenticationDefaults.AuthenticationScheme, options => + { + options.ResourceMetadata = new ProtectedResourceMetadata + { + Resource = resourceWithTrailingSlash, + AuthorizationServers = { OAuthServerUrl }, + ScopesSupported = ["mcp:tools"], + }; + }); + + await using var app = await StartMcpServerAsync(); + + // First, manually check the PRM document contains the trailing slash + using var metadataResponse = await HttpClient.GetAsync( + "/.well-known/oauth-protected-resource", + TestContext.Current.CancellationToken + ); + + Assert.Equal(HttpStatusCode.OK, metadataResponse.StatusCode); + + var metadata = await metadataResponse.Content.ReadFromJsonAsync( + McpJsonUtilities.DefaultOptions, + TestContext.Current.CancellationToken + ); + + Assert.NotNull(metadata); + Assert.Equal(resourceWithTrailingSlash, metadata.Resource); + Assert.Matches(@"/$", metadata.Resource); // Has trailing slash + + // Then authenticate with the client + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, + }, + }, HttpClient, LoggerFactory); + + // This should succeed with the explicitly configured trailing slash + // If the client incorrectly trimmed the slash, ValidResources would reject it + await using var client = await McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + } + + [Fact] + public async Task CanAuthenticate_WithLegacyServerWithoutProtectedResourceMetadata() + { + // 2025-03-26 backcompat: server does NOT serve PRM, but DOES serve auth server metadata. + // The client should fall back to using the MCP server's origin as the auth server + // and discover auth metadata from well-known URLs on that origin. + TestOAuthServer.ExpectResource = false; + + // Use JwtBearer as the challenge scheme so the 401 response does NOT include resource_metadata. + Builder.Services.Configure(options => options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme); + + // Legacy servers don't use resource-based audiences in tokens (no resource parameter is sent). + Builder.Services.Configure(JwtBearerDefaults.AuthenticationScheme, options => + { + options.TokenValidationParameters.ValidateAudience = false; + }); + + await using var app = Builder.Build(); + + // Capture HttpClient for use in the proxy middleware. + var httpClient = HttpClient; + + app.Use(async (context, next) => + { + // Return 404 for PRM to simulate a legacy server that doesn't support RFC 9728. + if (context.Request.Path.StartsWithSegments("/.well-known/oauth-protected-resource")) + { + context.Response.StatusCode = StatusCodes.Status404NotFound; + return; + } + + // Serve auth server metadata pointing to the MCP server's own endpoints. + // In a real 2025-03-26 deployment, the MCP server itself would be the auth server. + if (context.Request.Path.StartsWithSegments("/.well-known/oauth-authorization-server") || + context.Request.Path.StartsWithSegments("/.well-known/openid-configuration")) + { + context.Response.ContentType = "application/json"; + await context.Response.WriteAsync($$""" + { + "issuer": "{{OAuthServerUrl}}", + "authorization_endpoint": "{{McpServerUrl}}/authorize", + "token_endpoint": "{{McpServerUrl}}/token", + "registration_endpoint": "{{McpServerUrl}}/register", + "response_types_supported": ["code"], + "grant_types_supported": ["authorization_code", "refresh_token"], + "token_endpoint_auth_methods_supported": ["client_secret_post"], + "code_challenge_methods_supported": ["S256"] + } + """); + return; + } + + // Proxy OAuth endpoints to the real OAuth server. + // In a real 2025-03-26 deployment, the MCP server itself would host these endpoints. + var path = context.Request.Path.Value; + if (path is "/authorize" or "/token" or "/register") + { + var targetUrl = $"{OAuthServerUrl}{path}{context.Request.QueryString}"; + using var proxyRequest = new HttpRequestMessage(new HttpMethod(context.Request.Method), targetUrl); + + if (context.Request.ContentLength > 0 || context.Request.ContentType is not null) + { + proxyRequest.Content = new StreamContent(context.Request.Body); + if (context.Request.ContentType is not null) + { + proxyRequest.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse(context.Request.ContentType); + } + } + + if (context.Request.Headers.Authorization.Count > 0) + { + proxyRequest.Headers.TryAddWithoutValidation("Authorization", context.Request.Headers.Authorization.ToString()); + } + + using var response = await httpClient.SendAsync(proxyRequest); + context.Response.StatusCode = (int)response.StatusCode; + + if (response.Headers.Location is not null) + { + context.Response.Headers.Location = response.Headers.Location.ToString(); + } + + if (response.Content.Headers.ContentType is not null) + { + context.Response.ContentType = response.Content.Headers.ContentType.ToString(); + } + + await response.Content.CopyToAsync(context.Response.Body); + return; + } + + await next(); + }); + + app.UseAuthentication(); + app.UseAuthorization(); + app.MapMcp().RequireAuthorization(); + await app.StartAsync(TestContext.Current.CancellationToken); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, + }, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + } + + [Fact] + public async Task CanAuthenticate_WithLegacyServerUsingDefaultEndpointFallback() { - // 2025-03-26 backcompat: server does NOT serve PRM, but DOES serve auth server metadata. - // The client should fall back to using the MCP server's origin as the auth server - // and discover auth metadata from well-known URLs on that origin. + // 2025-03-26 backcompat: server does NOT serve PRM AND does NOT serve auth server metadata. + // The client should fall back to default endpoint paths (/authorize, /token, /register) + // on the MCP server's origin. TestOAuthServer.ExpectResource = false; // Use JwtBearer as the challenge scheme so the 401 response does NOT include resource_metadata. @@ -1059,90 +2076,315 @@ public async Task CanAuthenticate_WithLegacyServerWithoutProtectedResourceMetada // Legacy servers don't use resource-based audiences in tokens (no resource parameter is sent). Builder.Services.Configure(JwtBearerDefaults.AuthenticationScheme, options => { - options.TokenValidationParameters.ValidateAudience = false; + options.TokenValidationParameters.ValidateAudience = false; + }); + + await using var app = Builder.Build(); + + // Capture HttpClient for use in the proxy middleware. + var httpClient = HttpClient; + + app.Use(async (context, next) => + { + // Return 404 for PRM to simulate a legacy server that doesn't support RFC 9728. + if (context.Request.Path.StartsWithSegments("/.well-known/oauth-protected-resource")) + { + context.Response.StatusCode = StatusCodes.Status404NotFound; + return; + } + + // Return 404 for auth server metadata to force fallback to default endpoints. + if (context.Request.Path.StartsWithSegments("/.well-known/oauth-authorization-server") || + context.Request.Path.StartsWithSegments("/.well-known/openid-configuration")) + { + context.Response.StatusCode = StatusCodes.Status404NotFound; + return; + } + + // Proxy default OAuth endpoints to the real OAuth server. + // In a real 2025-03-26 deployment, the MCP server itself would host these endpoints. + var path = context.Request.Path.Value; + if (path is "/authorize" or "/token" or "/register") + { + var targetUrl = $"{OAuthServerUrl}{path}{context.Request.QueryString}"; + using var proxyRequest = new HttpRequestMessage(new HttpMethod(context.Request.Method), targetUrl); + + if (context.Request.ContentLength > 0 || context.Request.ContentType is not null) + { + proxyRequest.Content = new StreamContent(context.Request.Body); + if (context.Request.ContentType is not null) + { + proxyRequest.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse(context.Request.ContentType); + } + } + + if (context.Request.Headers.Authorization.Count > 0) + { + proxyRequest.Headers.TryAddWithoutValidation("Authorization", context.Request.Headers.Authorization.ToString()); + } + + using var response = await httpClient.SendAsync(proxyRequest); + context.Response.StatusCode = (int)response.StatusCode; + + if (response.Headers.Location is not null) + { + context.Response.Headers.Location = response.Headers.Location.ToString(); + } + + if (response.Content.Headers.ContentType is not null) + { + context.Response.ContentType = response.Content.Headers.ContentType.ToString(); + } + + await response.Content.CopyToAsync(context.Response.Body); + return; + } + + await next(); + }); + + app.UseAuthentication(); + app.UseAuthorization(); + app.MapMcp().RequireAuthorization(); + await app.StartAsync(TestContext.Current.CancellationToken); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, + }, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + } + + [Fact] + public async Task CannotAuthenticate_WithLegacyServerWhoseMetadataOmitsPkceMethods() + { + // 2025-03-26 backcompat regression guard: PRM is unavailable (resourceUri is null), but the server + // DOES serve an auth server metadata document that omits 'code_challenge_methods_supported'. + // The client must refuse to proceed rather than falling back to synthesized S256 defaults, since a + // discovered metadata document that fails PKCE validation disqualifies the legacy default fallback. + TestOAuthServer.ExpectResource = false; + + // Use JwtBearer as the challenge scheme so the 401 response does NOT include resource_metadata. + Builder.Services.Configure(options => options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme); + + Builder.Services.Configure(JwtBearerDefaults.AuthenticationScheme, options => + { + options.TokenValidationParameters.ValidateAudience = false; + }); + + await using var app = Builder.Build(); + + app.Use(async (context, next) => + { + // Return 404 for PRM to simulate a legacy server that doesn't support RFC 9728. + if (context.Request.Path.StartsWithSegments("/.well-known/oauth-protected-resource")) + { + context.Response.StatusCode = StatusCodes.Status404NotFound; + return; + } + + // Serve auth server metadata that omits 'code_challenge_methods_supported' entirely. + if (context.Request.Path.StartsWithSegments("/.well-known/oauth-authorization-server") || + context.Request.Path.StartsWithSegments("/.well-known/openid-configuration")) + { + context.Response.ContentType = "application/json"; + await context.Response.WriteAsync($$""" + { + "issuer": "{{OAuthServerUrl}}", + "authorization_endpoint": "{{McpServerUrl}}/authorize", + "token_endpoint": "{{McpServerUrl}}/token", + "registration_endpoint": "{{McpServerUrl}}/register", + "response_types_supported": ["code"], + "grant_types_supported": ["authorization_code", "refresh_token"], + "token_endpoint_auth_methods_supported": ["client_secret_post"] + } + """); + return; + } + + await next(); + }); + + app.UseAuthentication(); + app.UseAuthorization(); + app.MapMcp().RequireAuthorization(); + await app.StartAsync(TestContext.Current.CancellationToken); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, + }, + }, HttpClient, LoggerFactory); + + var ex = await Assert.ThrowsAsync(() => McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)); + + // The specific PKCE failure reason is surfaced rather than a generic discovery failure or a + // silently-synthesized S256 fallback. + Assert.Contains("code_challenge_methods_supported", ex.Message); + } + + [Fact] + public async Task AuthorizationFlow_AppendsOfflineAccess_WhenServerAdvertisesIt() + { + TestOAuthServer.IncludeOfflineAccessInMetadata = true; + await using var app = await StartMcpServerAsync(); + + string? requestedScope = null; + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = (context, ct) => + { + var query = QueryHelpers.ParseQuery(context.AuthorizationUri.Query); + requestedScope = query["scope"].ToString(); + return HandleAuthorizationUrlAsync(context, ct); + }, + }, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + + Assert.NotNull(requestedScope); + Assert.Contains("offline_access", requestedScope!.Split(' ')); + } + + [Fact] + public async Task AuthorizationFlow_DoesNotAppendOfflineAccess_WhenServerDoesNotAdvertiseIt() + { + // IncludeOfflineAccessInMetadata defaults to false, so the AS will not advertise offline_access. + await using var app = await StartMcpServerAsync(); + + string? requestedScope = null; + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = (context, ct) => + { + var query = QueryHelpers.ParseQuery(context.AuthorizationUri.Query); + requestedScope = query["scope"].ToString(); + return HandleAuthorizationUrlAsync(context, ct); + }, + }, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + + Assert.NotNull(requestedScope); + Assert.DoesNotContain("offline_access", requestedScope!.Split(' ')); + } + + [Fact] + public async Task AuthorizationFlow_DoesNotDuplicateOfflineAccess_WhenAlreadyPresent() + { + TestOAuthServer.IncludeOfflineAccessInMetadata = true; + + // Configure the PRM to already include offline_access in its scopes. + Builder.Services.Configure(McpAuthenticationDefaults.AuthenticationScheme, options => + { + options.ResourceMetadata!.ScopesSupported = ["mcp:tools", "offline_access"]; }); - await using var app = Builder.Build(); + await using var app = await StartMcpServerAsync(); - // Capture HttpClient for use in the proxy middleware. - var httpClient = HttpClient; + string? requestedScope = null; - app.Use(async (context, next) => + await using var transport = new HttpClientTransport(new() { - // Return 404 for PRM to simulate a legacy server that doesn't support RFC 9728. - if (context.Request.Path.StartsWithSegments("/.well-known/oauth-protected-resource")) + Endpoint = new(McpServerUrl), + OAuth = new() { - context.Response.StatusCode = StatusCodes.Status404NotFound; - return; - } + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = (context, ct) => + { + var query = QueryHelpers.ParseQuery(context.AuthorizationUri.Query); + requestedScope = query["scope"].ToString(); + return HandleAuthorizationUrlAsync(context, ct); + }, + }, + }, HttpClient, LoggerFactory); - // Serve auth server metadata pointing to the MCP server's own endpoints. - // In a real 2025-03-26 deployment, the MCP server itself would be the auth server. - if (context.Request.Path.StartsWithSegments("/.well-known/oauth-authorization-server") || - context.Request.Path.StartsWithSegments("/.well-known/openid-configuration")) - { - context.Response.ContentType = "application/json"; - await context.Response.WriteAsync($$""" - { - "issuer": "{{OAuthServerUrl}}", - "authorization_endpoint": "{{McpServerUrl}}/authorize", - "token_endpoint": "{{McpServerUrl}}/token", - "registration_endpoint": "{{McpServerUrl}}/register", - "response_types_supported": ["code"], - "grant_types_supported": ["authorization_code", "refresh_token"], - "token_endpoint_auth_methods_supported": ["client_secret_post"], - "code_challenge_methods_supported": ["S256"] - } - """); - return; - } + await using var client = await McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); - // Proxy OAuth endpoints to the real OAuth server. - // In a real 2025-03-26 deployment, the MCP server itself would host these endpoints. - var path = context.Request.Path.Value; - if (path is "/authorize" or "/token" or "/register") - { - var targetUrl = $"{OAuthServerUrl}{path}{context.Request.QueryString}"; - using var proxyRequest = new HttpRequestMessage(new HttpMethod(context.Request.Method), targetUrl); + Assert.NotNull(requestedScope); + var scopeTokens = requestedScope!.Split(' '); + Assert.Single(scopeTokens, t => t == "offline_access"); + } - if (context.Request.ContentLength > 0 || context.Request.ContentType is not null) - { - proxyRequest.Content = new StreamContent(context.Request.Body); - if (context.Request.ContentType is not null) - { - proxyRequest.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse(context.Request.ContentType); - } - } + [Fact] + public async Task AuthorizationFlow_ScopeSelector_CanFilterServerProposedScopes() + { + Builder.Services.Configure(McpAuthenticationDefaults.AuthenticationScheme, options => + { + options.ResourceMetadata!.ScopesSupported = ["mcp:tools", "files:read"]; + }); - if (context.Request.Headers.Authorization.Count > 0) - { - proxyRequest.Headers.TryAddWithoutValidation("Authorization", context.Request.Headers.Authorization.ToString()); - } + await using var app = await StartMcpServerAsync(); - using var response = await httpClient.SendAsync(proxyRequest); - context.Response.StatusCode = (int)response.StatusCode; + string? requestedScope = null; - if (response.Headers.Location is not null) + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = (context, ct) => { - context.Response.Headers.Location = response.Headers.Location.ToString(); - } + var query = QueryHelpers.ParseQuery(context.AuthorizationUri.Query); + requestedScope = query["scope"].ToString(); + return HandleAuthorizationUrlAsync(context, ct); + }, + ScopeSelector = scopes => scopes?.Where(s => s == "mcp:tools"), + }, + }, HttpClient, LoggerFactory); - if (response.Content.Headers.ContentType is not null) - { - context.Response.ContentType = response.Content.Headers.ContentType.ToString(); - } + await using var client = await McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); - await response.Content.CopyToAsync(context.Response.Body); - return; - } + Assert.Equal("mcp:tools", requestedScope); + } - await next(); - }); + [Fact] + public async Task AuthorizationFlow_ScopeSelector_CanAddCustomScope() + { + await using var app = await StartMcpServerAsync(); - app.UseAuthentication(); - app.UseAuthorization(); - app.MapMcp().RequireAuthorization(); - await app.StartAsync(TestContext.Current.CancellationToken); + string? requestedScope = null; await using var transport = new HttpClientTransport(new() { @@ -1152,99 +2394,95 @@ await context.Response.WriteAsync($$""" ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = HandleAuthorizationUrlAsync, + AuthorizationCallbackHandler = (context, ct) => + { + var query = QueryHelpers.ParseQuery(context.AuthorizationUri.Query); + requestedScope = query["scope"].ToString(); + return HandleAuthorizationUrlAsync(context, ct); + }, + ScopeSelector = scopes => scopes?.Append("custom:scope") ?? ["custom:scope"], }, }, HttpClient, LoggerFactory); await using var client = await McpClient.CreateAsync( transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + + Assert.NotNull(requestedScope); + Assert.Contains("custom:scope", requestedScope!.Split(' ')); } [Fact] - public async Task CanAuthenticate_WithLegacyServerUsingDefaultEndpointFallback() + public async Task AuthorizationFlow_ScopeSelector_ReceivesNull_WhenServerProvidesNoScopes() { - // 2025-03-26 backcompat: server does NOT serve PRM AND does NOT serve auth server metadata. - // The client should fall back to default endpoint paths (/authorize, /token, /register) - // on the MCP server's origin. - TestOAuthServer.ExpectResource = false; - - // Use JwtBearer as the challenge scheme so the 401 response does NOT include resource_metadata. - Builder.Services.Configure(options => options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme); - - // Legacy servers don't use resource-based audiences in tokens (no resource parameter is sent). - Builder.Services.Configure(JwtBearerDefaults.AuthenticationScheme, options => + // No ScopesSupported on PRM, no Scopes fallback on client, no offline_access on AS (default). + Builder.Services.Configure(McpAuthenticationDefaults.AuthenticationScheme, options => { - options.TokenValidationParameters.ValidateAudience = false; + options.ResourceMetadata!.ScopesSupported = []; }); - await using var app = Builder.Build(); + await using var app = await StartMcpServerAsync(); - // Capture HttpClient for use in the proxy middleware. - var httpClient = HttpClient; + IEnumerable? capturedInput = ["sentinel"]; - app.Use(async (context, next) => + await using var transport = new HttpClientTransport(new() { - // Return 404 for PRM to simulate a legacy server that doesn't support RFC 9728. - if (context.Request.Path.StartsWithSegments("/.well-known/oauth-protected-resource")) - { - context.Response.StatusCode = StatusCodes.Status404NotFound; - return; - } - - // Return 404 for auth server metadata to force fallback to default endpoints. - if (context.Request.Path.StartsWithSegments("/.well-known/oauth-authorization-server") || - context.Request.Path.StartsWithSegments("/.well-known/openid-configuration")) + Endpoint = new(McpServerUrl), + OAuth = new() { - context.Response.StatusCode = StatusCodes.Status404NotFound; - return; - } + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, + ScopeSelector = scopes => + { + capturedInput = scopes; + return scopes; + }, + }, + }, HttpClient, LoggerFactory); - // Proxy default OAuth endpoints to the real OAuth server. - // In a real 2025-03-26 deployment, the MCP server itself would host these endpoints. - var path = context.Request.Path.Value; - if (path is "/authorize" or "/token" or "/register") - { - var targetUrl = $"{OAuthServerUrl}{path}{context.Request.QueryString}"; - using var proxyRequest = new HttpRequestMessage(new HttpMethod(context.Request.Method), targetUrl); + await using var client = await McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); - if (context.Request.ContentLength > 0 || context.Request.ContentType is not null) - { - proxyRequest.Content = new StreamContent(context.Request.Body); - if (context.Request.ContentType is not null) - { - proxyRequest.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse(context.Request.ContentType); - } - } + Assert.Null(capturedInput); + } - if (context.Request.Headers.Authorization.Count > 0) - { - proxyRequest.Headers.TryAddWithoutValidation("Authorization", context.Request.Headers.Authorization.ToString()); - } + [Fact] + public async Task AuthorizationFlow_ScopeSelector_ReturningNull_OmitsScopeParameter() + { + await using var app = await StartMcpServerAsync(); - using var response = await httpClient.SendAsync(proxyRequest); - context.Response.StatusCode = (int)response.StatusCode; + bool? scopePresent = null; - if (response.Headers.Location is not null) + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = (context, ct) => { - context.Response.Headers.Location = response.Headers.Location.ToString(); - } + scopePresent = QueryHelpers.ParseQuery(context.AuthorizationUri.Query).ContainsKey("scope"); + return HandleAuthorizationUrlAsync(context, ct); + }, + ScopeSelector = _ => null, + }, + }, HttpClient, LoggerFactory); - if (response.Content.Headers.ContentType is not null) - { - context.Response.ContentType = response.Content.Headers.ContentType.ToString(); - } + await using var client = await McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); - await response.Content.CopyToAsync(context.Response.Body); - return; - } + Assert.False(scopePresent); + } - await next(); - }); + [Fact] + public async Task AuthorizationFlow_ScopeSelector_ReturningEmpty_OmitsScopeParameter() + { + await using var app = await StartMcpServerAsync(); - app.UseAuthentication(); - app.UseAuthorization(); - app.MapMcp().RequireAuthorization(); - await app.StartAsync(TestContext.Current.CancellationToken); + bool? scopePresent = null; await using var transport = new HttpClientTransport(new() { @@ -1254,11 +2492,61 @@ public async Task CanAuthenticate_WithLegacyServerUsingDefaultEndpointFallback() ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = HandleAuthorizationUrlAsync, + AuthorizationCallbackHandler = (context, ct) => + { + scopePresent = QueryHelpers.ParseQuery(context.AuthorizationUri.Query).ContainsKey("scope"); + return HandleAuthorizationUrlAsync(context, ct); + }, + ScopeSelector = _ => [], + }, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + + Assert.False(scopePresent); + } + + private HttpClientTransport CreateOAuthTransport( + Func>? + authorizationCallbackHandler = null) => + new(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = authorizationCallbackHandler ?? HandleAuthorizationUrlAsync, + }, + }, HttpClient, LoggerFactory); + + [Fact] + public async Task DynamicClientRegistration_ScopeSelector_AppliesToDcrScope() + { + Builder.Services.Configure(McpAuthenticationDefaults.AuthenticationScheme, options => + { + options.ResourceMetadata!.ScopesSupported = ["mcp:tools", "files:read"]; + }); + + await using var app = await StartMcpServerAsync(); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new ClientOAuthOptions() + { + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, + DynamicClientRegistration = new() { ClientName = "Test MCP Client" }, + ScopeSelector = scopes => scopes?.Where(s => s == "mcp:tools"), }, }, HttpClient, LoggerFactory); await using var client = await McpClient.CreateAsync( transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + + Assert.Equal("mcp:tools", TestOAuthServer.LastRegistrationScope); } } diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/OAuth/DcrFailureTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/OAuth/DcrFailureTests.cs new file mode 100644 index 000000000..43a69de68 --- /dev/null +++ b/tests/ModelContextProtocol.AspNetCore.Tests/OAuth/DcrFailureTests.cs @@ -0,0 +1,92 @@ +using ModelContextProtocol.Authentication; +using ModelContextProtocol.Client; + +namespace ModelContextProtocol.AspNetCore.Tests.OAuth; + +// SEP-837: the SDK doesn't surface or retry DCR failures itself, but a consumer built on the SDK +// must be able to. These tests prove that surface: a rejected registration propagates with enough +// context to build a meaningful error, and a consumer can retry with an adjusted redirect URI. +public class DcrFailureTests : OAuthTestBase +{ + public DcrFailureTests(ITestOutputHelper outputHelper) + : base(outputHelper) + { + } + + [Fact] + public async Task DcrRejection_PropagatesToConsumer_WithStatusBodyAndSentParameters() + { + await using var app = await StartMcpServerAsync(); + + // A custom-scheme redirect URI infers application_type "native"; the OIDC AS rejects it + // with 400 invalid_redirect_uri because it only registers http/https redirect URIs. + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new ClientOAuthOptions() + { + RedirectUri = new Uri("myapp://callback"), + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, + DynamicClientRegistration = new() { ClientName = "Test MCP Client" }, + }, + }, HttpClient, LoggerFactory); + + var ex = await Assert.ThrowsAsync(() => McpClient.CreateAsync( + transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)); + + // The consumer needs enough to produce a meaningful error: the HTTP status, the AS error + // body (which echoes the redirect URI), and the application_type the SDK actually sent. + Assert.Contains("BadRequest", ex.Message); + Assert.Contains("invalid_redirect_uri", ex.Message); + Assert.Contains("native", ex.Message); + } + + [Fact] + public async Task ConsumerCanRetryRegistration_WithAdjustedRedirectUri_AfterRejection() + { + await using var app = await StartMcpServerAsync(); + + // First attempt: a custom-scheme redirect (native) is rejected by the AS. ApplicationType + // is held constant at "native" so only the redirect URI changes between the two attempts. + await using var firstTransport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new ClientOAuthOptions() + { + RedirectUri = new Uri("myapp://callback"), + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, + DynamicClientRegistration = new() + { + ClientName = "Test MCP Client", + ApplicationType = "native", + }, + }, + }, HttpClient, LoggerFactory); + + await Assert.ThrowsAsync(() => McpClient.CreateAsync( + firstTransport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)); + + // Second attempt: a new provider on the SAME HttpClient with an adjusted (loopback) redirect + // URI that the AS accepts. The retry must succeed, proving the SEP-837 MAY-retry surface works + // and that the rejected attempt left no client state behind. + await using var secondTransport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new ClientOAuthOptions() + { + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, + DynamicClientRegistration = new() + { + ClientName = "Test MCP Client", + ApplicationType = "native", + }, + }, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync( + secondTransport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + + Assert.Equal("native", TestOAuthServer.LastApplicationType); + } +} diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/OAuth/DefaultAuthorizationUrlHandlerTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/OAuth/DefaultAuthorizationUrlHandlerTests.cs new file mode 100644 index 000000000..825ebe2fb --- /dev/null +++ b/tests/ModelContextProtocol.AspNetCore.Tests/OAuth/DefaultAuthorizationUrlHandlerTests.cs @@ -0,0 +1,46 @@ +using ModelContextProtocol.Authentication; +using ModelContextProtocol.Client; + +namespace ModelContextProtocol.AspNetCore.Tests.OAuth; + +[CollectionDefinition(nameof(DisableConsoleParallelization), DisableParallelization = true)] +public sealed class DisableConsoleParallelization; + +[Collection(nameof(DisableConsoleParallelization))] +public class DefaultAuthorizationUrlHandlerTests(ITestOutputHelper outputHelper) : OAuthTestBase(outputHelper) +{ + [Fact] + public async Task RejectsAuthorizationCodeWithoutAbsoluteRedirectUrl() + { + await using var app = await StartMcpServerAsync(); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + }, + }, HttpClient, LoggerFactory); + + var originalInput = Console.In; + using var consoleInput = new StringReader("authorization-code"); + Console.SetIn(consoleInput); + + try + { + var ex = await Assert.ThrowsAsync(() => McpClient.CreateAsync( + transport, + loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken)); + + Assert.Contains("not a valid absolute URL", ex.Message); + } + finally + { + Console.SetIn(originalInput); + } + } +} diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/OAuth/IdentityAssertionGrantIntegrationTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/OAuth/IdentityAssertionGrantIntegrationTests.cs new file mode 100644 index 000000000..6972fa4b4 --- /dev/null +++ b/tests/ModelContextProtocol.AspNetCore.Tests/OAuth/IdentityAssertionGrantIntegrationTests.cs @@ -0,0 +1,167 @@ +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.Authentication; +using ModelContextProtocol.Client; +using System.Net.Http.Headers; + +namespace ModelContextProtocol.AspNetCore.Tests.OAuth; + +/// +/// Integration tests for Cross-Application Access authorization using the in-memory +/// test OAuth server as a stand-in for both the enterprise Identity Provider (IdP) and +/// the MCP Authorization Server (AS). +/// +/// Flow exercised: +/// 1. discovers the MCP AS +/// metadata and calls the ID token callback. +/// 2. The provider performs RFC 8693 token exchange at /idp/token on the test OAuth server +/// (ID token → JAG). +/// 3. The provider exchanges the JAG for an access token at /token +/// (RFC 7523 JWT-bearer grant: JAG → access token). +/// 4. The access token is passed to the MCP client transport and used to authenticate +/// against the protected MCP server. +/// +public class IdentityAssertionGrantIntegrationTests : OAuthTestBase +{ + public IdentityAssertionGrantIntegrationTests(ITestOutputHelper outputHelper) + : base(outputHelper) + { + } + + [Fact] + public async Task CanAuthenticate_WithIdentityAssertionGrantProvider() + { + // Enable Enterprise Managed Authorization endpoints on the test OAuth server. + TestOAuthServer.EnterpriseSupportEnabled = true; + + await using var app = await StartMcpServerAsync(); + + // Simulate the enterprise ID token that would normally come from the SSO login step. + const string simulatedIdToken = "test-enterprise-sso-id-token"; + + // Create the provider with IdP config folded into options. + // The ID token callback just returns the SSO ID token; the provider performs + // RFC 8693 (ID token → JAG) and RFC 7523 (JAG → access token) internally. + var provider = new IdentityAssertionGrantProvider( + new IdentityAssertionGrantProviderOptions + { + ClientId = "enterprise-mcp-client", + ClientSecret = "enterprise-mcp-secret", + IdpTokenEndpoint = $"{OAuthServerUrl}/idp/token", + IdpClientId = "enterprise-idp-client", + IdpClientSecret = "enterprise-idp-secret", + IdTokenCallback = (_, ct) => Task.FromResult(simulatedIdToken), + }, + httpClient: HttpClient); + + // Run the full Cross-Application Access flow: discover AS → get JAG → exchange for access token. + var tokens = await provider.GetAccessTokenAsync( + resourceUrl: new Uri(McpServerUrl), + authorizationServerUrl: new Uri(OAuthServerUrl), + cancellationToken: TestContext.Current.CancellationToken); + + Assert.NotNull(tokens.AccessToken); + Assert.False(string.IsNullOrEmpty(tokens.AccessToken)); + Assert.Equal("bearer", tokens.TokenType, ignoreCase: true); + + // Wire the obtained access token into an HTTP client that shares the same + // in-memory Kestrel transport as the rest of the test fixture. + var mcpHttpClient = new HttpClient(SocketsHttpHandler, disposeHandler: false); + ConfigureHttpClient(mcpHttpClient); + mcpHttpClient.DefaultRequestHeaders.Authorization = + new AuthenticationHeaderValue("Bearer", tokens.AccessToken); + + // Connect the MCP client using the enterprise access token — no interactive OAuth flow. + await using var transport = new HttpClientTransport( + new HttpClientTransportOptions { Endpoint = new Uri(McpServerUrl) }, + mcpHttpClient, + LoggerFactory); + + await using var client = await McpClient.CreateAsync( + transport, + loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken); + + // If we get here the MCP server accepted the enterprise access token. + Assert.NotNull(client); + } + + [Fact] + public async Task IdentityAssertionGrantProvider_ReturnsCachedToken_OnSecondCall() + { + TestOAuthServer.EnterpriseSupportEnabled = true; + + await using var _ = await StartMcpServerAsync(); + + var idTokenCallCount = 0; + + var provider = new IdentityAssertionGrantProvider( + new IdentityAssertionGrantProviderOptions + { + ClientId = "enterprise-mcp-client", + ClientSecret = "enterprise-mcp-secret", + IdpTokenEndpoint = $"{OAuthServerUrl}/idp/token", + IdpClientId = "enterprise-idp-client", + IdpClientSecret = "enterprise-idp-secret", + IdTokenCallback = (_, ct) => + { + idTokenCallCount++; + return Task.FromResult("test-sso-token"); + }, + }, + httpClient: HttpClient); + + var tokens1 = await provider.GetAccessTokenAsync( + new Uri(McpServerUrl), new Uri(OAuthServerUrl), + TestContext.Current.CancellationToken); + + var tokens2 = await provider.GetAccessTokenAsync( + new Uri(McpServerUrl), new Uri(OAuthServerUrl), + TestContext.Current.CancellationToken); + + // The ID token callback (and therefore the IdP round-trip) should only fire once. + Assert.Equal(1, idTokenCallCount); + Assert.Equal(tokens1.AccessToken, tokens2.AccessToken); + } + + [Fact] + public async Task IdentityAssertionGrantProvider_FetchesFreshToken_AfterInvalidateCache() + { + TestOAuthServer.EnterpriseSupportEnabled = true; + + await using var _ = await StartMcpServerAsync(); + + var idTokenCallCount2 = 0; + + var provider2 = new IdentityAssertionGrantProvider( + new IdentityAssertionGrantProviderOptions + { + ClientId = "enterprise-mcp-client", + ClientSecret = "enterprise-mcp-secret", + IdpTokenEndpoint = $"{OAuthServerUrl}/idp/token", + IdpClientId = "enterprise-idp-client", + IdpClientSecret = "enterprise-idp-secret", + IdTokenCallback = (_, ct) => + { + idTokenCallCount2++; + return Task.FromResult("test-sso-token"); + }, + }, + httpClient: HttpClient); + + var tokens1 = await provider2.GetAccessTokenAsync( + new Uri(McpServerUrl), new Uri(OAuthServerUrl), + TestContext.Current.CancellationToken); + + // Invalidate the cache to force a full re-exchange. + provider2.InvalidateCache(); + + var tokens2 = await provider2.GetAccessTokenAsync( + new Uri(McpServerUrl), new Uri(OAuthServerUrl), + TestContext.Current.CancellationToken); + + // The IdP should have been called twice — once for each GetAccessTokenAsync after invalidation. + Assert.Equal(2, idTokenCallCount2); + // The tokens may or may not be identical depending on timing, but the flow ran again. + Assert.NotNull(tokens2.AccessToken); + } +} diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/OAuth/OAuthTestBase.cs b/tests/ModelContextProtocol.AspNetCore.Tests/OAuth/OAuthTestBase.cs index 3c1919b0b..80167b0c9 100644 --- a/tests/ModelContextProtocol.AspNetCore.Tests/OAuth/OAuthTestBase.cs +++ b/tests/ModelContextProtocol.AspNetCore.Tests/OAuth/OAuthTestBase.cs @@ -62,7 +62,7 @@ protected OAuthTestBase(ITestOutputHelper outputHelper, bool configureMcpMetadat }); Builder.Services.AddAuthorization(); - Builder.Services.AddMcpServer().WithHttpTransport(); + Builder.Services.AddMcpServer().WithHttpTransport(options => options.Stateless = false); } public async ValueTask DisposeAsync() @@ -106,18 +106,41 @@ protected async Task StartMcpServerAsync(string path = "", strin return app; } - protected async Task HandleAuthorizationUrlAsync(Uri authorizationUri, Uri redirectUri, CancellationToken cancellationToken) + protected async Task HandleAuthorizationUrlAsync( + ModelContextProtocol.Authentication.AuthorizationCallbackContext authorizationContext, + CancellationToken cancellationToken) { - using var redirectResponse = await HttpClient.GetAsync(authorizationUri, cancellationToken); + using var redirectResponse = await HttpClient.GetAsync(authorizationContext.AuthorizationUri, cancellationToken); Assert.Equal(HttpStatusCode.Redirect, redirectResponse.StatusCode); var location = redirectResponse.Headers.Location; if (location is not null && !string.IsNullOrEmpty(location.Query)) { var queryParams = QueryHelpers.ParseQuery(location.Query); - return queryParams["code"]; + return new ModelContextProtocol.Authentication.AuthorizationResult + { + Code = queryParams["code"], + State = queryParams["state"], + Iss = queryParams.TryGetValue("iss", out var iss) ? (string?)iss : null, + }; } return null; } + + protected async Task HandleAuthorizationUrlAsync( + Uri authorizationUri, + Uri redirectUri, + CancellationToken cancellationToken) + { + var result = await HandleAuthorizationUrlAsync( + new ModelContextProtocol.Authentication.AuthorizationCallbackContext + { + AuthorizationUri = authorizationUri, + RedirectUri = redirectUri, + }, + cancellationToken); + + return result?.Code; + } } diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/OAuth/TokenCacheTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/OAuth/TokenCacheTests.cs index fb9e2bfda..5b6f054ba 100644 --- a/tests/ModelContextProtocol.AspNetCore.Tests/OAuth/TokenCacheTests.cs +++ b/tests/ModelContextProtocol.AspNetCore.Tests/OAuth/TokenCacheTests.cs @@ -1,5 +1,6 @@ using ModelContextProtocol.Authentication; using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; namespace ModelContextProtocol.AspNetCore.Tests.OAuth; @@ -26,10 +27,10 @@ public async Task GetTokenAsync_CachedAccessTokenIsUsedForOutgoingRequests() ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = (uri, redirect, ct) => + AuthorizationCallbackHandler = (context, ct) => { authDelegateCalledInitially = true; - return HandleAuthorizationUrlAsync(uri, redirect, ct); + return HandleAuthorizationUrlAsync(context, ct); }, TokenCache = tokenCache, }, @@ -40,7 +41,7 @@ public async Task GetTokenAsync_CachedAccessTokenIsUsedForOutgoingRequests() // Just connecting should trigger auth and storage. } - Assert.True(authDelegateCalledInitially, "AuthorizationRedirectDelegate should be called to get initial token"); + Assert.True(authDelegateCalledInitially, "AuthorizationCallbackHandler should be called to get initial token"); Assert.NotNull(tokenCache.LastStoredToken); var authDelegateCalledAgain = false; @@ -53,10 +54,10 @@ public async Task GetTokenAsync_CachedAccessTokenIsUsedForOutgoingRequests() ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = (uri, redirect, ct) => + AuthorizationCallbackHandler = (context, ct) => { authDelegateCalledAgain = true; - return HandleAuthorizationUrlAsync(uri, redirect, ct); + return HandleAuthorizationUrlAsync(context, ct); }, TokenCache = tokenCache }, @@ -64,7 +65,7 @@ public async Task GetTokenAsync_CachedAccessTokenIsUsedForOutgoingRequests() await using var client = await McpClient.CreateAsync(transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); - Assert.False(authDelegateCalledAgain, "AuthorizationRedirectDelegate should not be called when token is valid"); + Assert.False(authDelegateCalledAgain, "AuthorizationCallbackHandler should not be called when token is valid"); } [Fact] @@ -82,7 +83,7 @@ public async Task StoreTokenAsync_NewlyAcquiredAccessTokenIsCached() ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = HandleAuthorizationUrlAsync, + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, TokenCache = tokenCache }, }, HttpClient, LoggerFactory); @@ -109,10 +110,10 @@ public async Task GetTokenAsync_InvalidCachedTokenTriggersAuthDelegate() ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = (uri, redirect, ct) => + AuthorizationCallbackHandler = (context, ct) => { authDelegateCalled = true; - return HandleAuthorizationUrlAsync(uri, redirect, ct); + return HandleAuthorizationUrlAsync(context, ct); }, TokenCache = tokenCache, }, @@ -120,7 +121,7 @@ public async Task GetTokenAsync_InvalidCachedTokenTriggersAuthDelegate() await using var client = await McpClient.CreateAsync(transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); - Assert.True(authDelegateCalled, "AuthorizationRedirectDelegate should be called when cached token is invalid"); + Assert.True(authDelegateCalled, "AuthorizationCallbackHandler should be called when cached token is invalid"); Assert.NotNull(tokenCache.LastStoredToken); Assert.NotEqual("invalid-token", tokenCache.LastStoredToken.AccessToken); } @@ -141,10 +142,10 @@ public async Task GetTokenAsync_InvalidAccessTokenTriggersRefresh() ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = (uri, redirect, ct) => + AuthorizationCallbackHandler = (context, ct) => { authDelegateCalledInitially = true; - return HandleAuthorizationUrlAsync(uri, redirect, ct); + return HandleAuthorizationUrlAsync(context, ct); }, TokenCache = tokenCache, }, @@ -155,7 +156,7 @@ public async Task GetTokenAsync_InvalidAccessTokenTriggersRefresh() // Just connecting should trigger auth and storage. } - Assert.True(authDelegateCalledInitially, "AuthorizationRedirectDelegate should be called to get initial token"); + Assert.True(authDelegateCalledInitially, "AuthorizationCallbackHandler should be called to get initial token"); Assert.False(TestOAuthServer.HasRefreshedToken, "Token should not have been refreshed yet"); Assert.NotNull(tokenCache.LastStoredToken); @@ -171,10 +172,10 @@ public async Task GetTokenAsync_InvalidAccessTokenTriggersRefresh() ClientId = "demo-client", ClientSecret = "demo-secret", RedirectUri = new Uri("http://localhost:1179/callback"), - AuthorizationRedirectDelegate = (uri, redirect, ct) => + AuthorizationCallbackHandler = (context, ct) => { authDelegateCalledAgain = true; - return HandleAuthorizationUrlAsync(uri, redirect, ct); + return HandleAuthorizationUrlAsync(context, ct); }, TokenCache = tokenCache }, @@ -182,11 +183,447 @@ public async Task GetTokenAsync_InvalidAccessTokenTriggersRefresh() await using var client = await McpClient.CreateAsync(transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); - Assert.False(authDelegateCalledAgain, "AuthorizationRedirectDelegate should not be called when refresh token is valid"); + Assert.False(authDelegateCalledAgain, "AuthorizationCallbackHandler should not be called when refresh token is valid"); Assert.True(TestOAuthServer.HasRefreshedToken, "Token should have been refreshed"); Assert.NotEqual("invalid-token", tokenCache.LastStoredToken.AccessToken); } + [Fact] + public async Task GetTokenAsync_ExplicitClientDoesNotRefreshTokenFromDifferentAuthorizationServer() + { + await using var app = await StartMcpServerAsync(); + + var tokenCache = new TestTokenCache(); + await using var setupTransport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, + TokenCache = tokenCache, + }, + }, HttpClient, LoggerFactory); + + await using (var setupClient = await McpClient.CreateAsync( + setupTransport, + loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken)) + { + } + + Assert.NotNull(tokenCache.LastStoredToken); + tokenCache.LastStoredToken.AccessToken = "invalid-token"; + tokenCache.LastStoredToken.AuthorizationServer = "https://different-authorization-server.example.com"; + var authorizationCallbackCalled = false; + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = (context, ct) => + { + authorizationCallbackCalled = true; + return HandleAuthorizationUrlAsync(context, ct); + }, + TokenCache = tokenCache, + }, + }, HttpClient, LoggerFactory); + + var exception = await Assert.ThrowsAsync(() => McpClient.CreateAsync( + transport, + loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken)); + + Assert.Contains("explicitly configured client credentials", exception.Message); + Assert.False(authorizationCallbackCalled); + Assert.False(TestOAuthServer.HasRefreshedToken); + Assert.Equal("https://different-authorization-server.example.com", tokenCache.LastStoredToken.AuthorizationServer); + } + + [Fact] + public async Task GetTokenAsync_ExplicitClientDoesNotRefreshTokenIssuedToDifferentClient() + { + await using var app = await StartMcpServerAsync(); + + var tokenCache = new TestTokenCache(); + await using var setupTransport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, + TokenCache = tokenCache, + }, + }, HttpClient, LoggerFactory); + + await using (var setupClient = await McpClient.CreateAsync( + setupTransport, + loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken)) + { + } + + Assert.NotNull(tokenCache.LastStoredToken); + tokenCache.LastStoredToken.AccessToken = "invalid-token"; + tokenCache.LastStoredToken.ClientId = "different-client"; + var authorizationCallbackCalled = false; + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = (context, ct) => + { + authorizationCallbackCalled = true; + return HandleAuthorizationUrlAsync(context, ct); + }, + TokenCache = tokenCache, + }, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync( + transport, + loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken); + + Assert.True(authorizationCallbackCalled); + Assert.False(TestOAuthServer.HasRefreshedToken); + Assert.Equal("demo-client", tokenCache.LastStoredToken.ClientId); + Assert.Equal(OAuthServerUrl, tokenCache.LastStoredToken.AuthorizationServer); + } + + [Fact] + public async Task GetTokenAsync_ExplicitClientWithLegacyUnboundCache_Reauthorizes() + { + await using var app = await StartMcpServerAsync(); + + var tokenCache = new TestTokenCache(); + await using var setupTransport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, + TokenCache = tokenCache, + }, + }, HttpClient, LoggerFactory); + + await using (var setupClient = await McpClient.CreateAsync( + setupTransport, + loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken)) + { + } + + Assert.NotNull(tokenCache.LastStoredToken); + tokenCache.LastStoredToken.AccessToken = "invalid-token"; + tokenCache.LastStoredToken.AuthorizationServer = null; + var authorizationCallbackCalled = false; + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + ClientId = "demo-client", + ClientSecret = "demo-secret", + RedirectUri = new Uri("http://localhost:1179/callback"), + AuthorizationCallbackHandler = (context, ct) => + { + authorizationCallbackCalled = true; + return HandleAuthorizationUrlAsync(context, ct); + }, + TokenCache = tokenCache, + }, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync( + transport, + loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken); + + Assert.True(authorizationCallbackCalled); + Assert.False(TestOAuthServer.HasRefreshedToken); + Assert.Equal(OAuthServerUrl, tokenCache.LastStoredToken.AuthorizationServer); + } + + [Fact] + public async Task GetTokenAsync_ColdStartWithDynamicRegistration_RefreshesUsingPersistedCredentials() + { + await using var app = await StartMcpServerAsync(); + + var tokenCache = new TestTokenCache(); + var authDelegateCalledInitially = false; + + // First "process": no ClientId is configured, so the client registers dynamically. + await using var setupTransport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + RedirectUri = new Uri("http://localhost:1179/callback"), + DynamicClientRegistration = new() + { + ClientName = "Test MCP Client", + ClientUri = new Uri("https://example.com"), + }, + AuthorizationCallbackHandler = (context, ct) => + { + authDelegateCalledInitially = true; + return HandleAuthorizationUrlAsync(context, ct); + }, + TokenCache = tokenCache, + }, + }, HttpClient, LoggerFactory); + + await using (var setupClient = await McpClient.CreateAsync(setupTransport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)) + { + // Just connecting should trigger dynamic registration, authorization, and storage. + } + + Assert.True(authDelegateCalledInitially, "Authorization callback should be called for the initial authorization"); + Assert.False(TestOAuthServer.HasRefreshedToken, "Token should not have been refreshed yet"); + Assert.NotNull(tokenCache.LastStoredToken); + Assert.False( + string.IsNullOrEmpty(tokenCache.LastStoredToken.ClientId), + "The dynamically registered client ID should be persisted alongside the tokens"); + Assert.Equal(OAuthServerUrl, tokenCache.LastStoredToken.AuthorizationServer); + + // Simulate a cold start: the access token is no longer valid, but the refresh token persists. + // The new provider has no client ID configured and must restore it from the cache to refresh + // instead of throwing "Client ID is not available". + tokenCache.LastStoredToken.AccessToken = "invalid-token"; + var authDelegateCalledAgain = false; + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + RedirectUri = new Uri("http://localhost:1179/callback"), + DynamicClientRegistration = new() + { + ClientName = "Test MCP Client", + ClientUri = new Uri("https://example.com"), + }, + AuthorizationCallbackHandler = (context, ct) => + { + authDelegateCalledAgain = true; + return HandleAuthorizationUrlAsync(context, ct); + }, + TokenCache = tokenCache, + }, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync(transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + + Assert.False(authDelegateCalledAgain, "Authorization callback should not be called when the persisted refresh token can be used"); + Assert.True(TestOAuthServer.HasRefreshedToken, "Token should have been refreshed using the persisted client credentials"); + Assert.NotEqual("invalid-token", tokenCache.LastStoredToken.AccessToken); + } + + [Fact] + public async Task GetTokenAsync_ColdStartWithCredentialsFromDifferentAuthorizationServer_Reregisters() + { + await using var app = await StartMcpServerAsync(); + + var tokenCache = new TestTokenCache(); + await using var setupTransport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + RedirectUri = new Uri("http://localhost:1179/callback"), + DynamicClientRegistration = new() { ClientName = "Test MCP Client" }, + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, + TokenCache = tokenCache, + }, + }, HttpClient, LoggerFactory); + + await using (var setupClient = await McpClient.CreateAsync( + setupTransport, + loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken)) + { + } + + Assert.NotNull(tokenCache.LastStoredToken); + tokenCache.LastStoredToken.AccessToken = "invalid-token"; + tokenCache.LastStoredToken.AuthorizationServer = "https://different-authorization-server.example.com"; + var authorizationCallbackCalled = false; + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + RedirectUri = new Uri("http://localhost:1179/callback"), + DynamicClientRegistration = new() { ClientName = "Test MCP Client" }, + AuthorizationCallbackHandler = (context, ct) => + { + authorizationCallbackCalled = true; + return HandleAuthorizationUrlAsync(context, ct); + }, + TokenCache = tokenCache, + }, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync( + transport, + loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken); + + Assert.True(authorizationCallbackCalled); + Assert.False(TestOAuthServer.HasRefreshedToken); + Assert.Equal(OAuthServerUrl, tokenCache.LastStoredToken.AuthorizationServer); + } + + [Fact] + public async Task GetTokenAsync_ColdStartWithLegacyUnboundCredentials_Reregisters() + { + await using var app = await StartMcpServerAsync(); + + var tokenCache = new TestTokenCache(); + await using var setupTransport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + RedirectUri = new Uri("http://localhost:1179/callback"), + DynamicClientRegistration = new() { ClientName = "Test MCP Client" }, + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, + TokenCache = tokenCache, + }, + }, HttpClient, LoggerFactory); + + await using (var setupClient = await McpClient.CreateAsync( + setupTransport, + loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken)) + { + } + + Assert.NotNull(tokenCache.LastStoredToken); + Assert.False(string.IsNullOrEmpty(tokenCache.LastStoredToken.ClientId)); + tokenCache.LastStoredToken.AccessToken = "invalid-token"; + tokenCache.LastStoredToken.AuthorizationServer = null; + var authorizationCallbackCalled = false; + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + RedirectUri = new Uri("http://localhost:1179/callback"), + DynamicClientRegistration = new() { ClientName = "Test MCP Client" }, + AuthorizationCallbackHandler = (context, ct) => + { + authorizationCallbackCalled = true; + return HandleAuthorizationUrlAsync(context, ct); + }, + TokenCache = tokenCache, + }, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync( + transport, + loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken); + + Assert.True(authorizationCallbackCalled); + Assert.False(TestOAuthServer.HasRefreshedToken); + Assert.Equal(OAuthServerUrl, tokenCache.LastStoredToken.AuthorizationServer); + } + + [Fact] + public async Task GetTokenAsync_ColdStartWithoutPersistedClientId_FallsBackToReauthorization() + { + await using var app = await StartMcpServerAsync(); + + var tokenCache = new TestTokenCache(); + var authDelegateCalledInitially = false; + + await using var setupTransport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + RedirectUri = new Uri("http://localhost:1179/callback"), + DynamicClientRegistration = new() + { + ClientName = "Test MCP Client", + ClientUri = new Uri("https://example.com"), + }, + AuthorizationCallbackHandler = (context, ct) => + { + authDelegateCalledInitially = true; + return HandleAuthorizationUrlAsync(context, ct); + }, + TokenCache = tokenCache, + }, + }, HttpClient, LoggerFactory); + + await using (var setupClient = await McpClient.CreateAsync(setupTransport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)) + { + } + + Assert.True(authDelegateCalledInitially, "Authorization callback should be called for the initial authorization"); + Assert.NotNull(tokenCache.LastStoredToken); + + // Simulate a durable cache that persisted tokens but not the client registration (for example + // an entry written by an older version). On a cold start the provider cannot refresh without a + // client ID and must fall back to a fresh authorization rather than throwing. + tokenCache.LastStoredToken.AccessToken = "invalid-token"; + tokenCache.LastStoredToken.ClientId = null; + tokenCache.LastStoredToken.ClientSecret = null; + tokenCache.LastStoredToken.TokenEndpointAuthMethod = null; + var authDelegateCalledAgain = false; + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new(McpServerUrl), + OAuth = new() + { + RedirectUri = new Uri("http://localhost:1179/callback"), + DynamicClientRegistration = new() + { + ClientName = "Test MCP Client", + ClientUri = new Uri("https://example.com"), + }, + AuthorizationCallbackHandler = (context, ct) => + { + authDelegateCalledAgain = true; + return HandleAuthorizationUrlAsync(context, ct); + }, + TokenCache = tokenCache, + }, + }, HttpClient, LoggerFactory); + + // Should not throw "Client ID is not available"; instead re-authorizes via dynamic + // registration and the authorization-code flow. + await using var client = await McpClient.CreateAsync(transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + + Assert.True(authDelegateCalledAgain, "Authorization callback should be called to re-authorize when no client ID is available to refresh"); + Assert.False(TestOAuthServer.HasRefreshedToken, "A refresh should not be attempted without a client ID"); + } + private TokenContainer CreateInvalidToken() { return new TokenContainer diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/RawHttpConformanceTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/RawHttpConformanceTests.cs new file mode 100644 index 000000000..0fce6dc08 --- /dev/null +++ b/tests/ModelContextProtocol.AspNetCore.Tests/RawHttpConformanceTests.cs @@ -0,0 +1,509 @@ +using Microsoft.AspNetCore.Builder; +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.AspNetCore.Tests.Utils; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using ModelContextProtocol.Tests.Utils; +using System.Net; +using System.Text; +using System.Text.Json; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.AspNetCore.Tests; + +/// +/// Wire-format conformance tests for the Streamable HTTP server driven directly via , +/// without going through . These hand-craft HTTP +/// requests and assert the exact status codes / response bodies the server emits for the SEP-2575 + +/// SEP-2567 2026-07-28 protocol revision. +/// +public class RawHttpConformanceTests(ITestOutputHelper outputHelper) : KestrelInMemoryTest(outputHelper), IAsyncDisposable +{ + private const string ProtocolVersionHeader = "MCP-Protocol-Version"; + + private WebApplication? _app; + + private async Task StartAsync(string? protocolVersion = null) + { + Builder.Services + .AddMcpServer(options => + { + options.ServerInfo = new Implementation { Name = nameof(RawHttpConformanceTests), Version = "1.0" }; + options.ProtocolVersion = protocolVersion; + }) + .WithHttpTransport() + .WithTools([McpServerTool.Create((string text) => $"echo:{text}", new() { Name = "echo" })]) + .WithTools(); + + _app = Builder.Build(); + _app.MapMcp(); + await _app.StartAsync(TestContext.Current.CancellationToken); + + HttpClient.DefaultRequestHeaders.Accept.Add(new("application/json")); + HttpClient.DefaultRequestHeaders.Accept.Add(new("text/event-stream")); + } + + public async ValueTask DisposeAsync() + { + if (_app is not null) + { + await _app.DisposeAsync(); + } + base.Dispose(); + } + + private static StringContent JsonContent(string json) => new(json, Encoding.UTF8, "application/json"); + + /// + /// Reads either a direct JSON response or a single SSE message containing JSON-RPC and returns the + /// parsed JsonNode. The Streamable HTTP server can return either content type depending on negotiation; + /// raw HttpClient tests should accept either. + /// + private static async Task ReadJsonResponseAsync(HttpResponseMessage response, CancellationToken cancellationToken) + { + var contentType = response.Content.Headers.ContentType?.MediaType; + var body = await response.Content.ReadAsStringAsync(cancellationToken); + + if (contentType == "text/event-stream") + { + // Pull the first non-empty data: line out of the SSE payload. + foreach (var line in body.Split('\n')) + { + if (line.StartsWith("data:", StringComparison.Ordinal)) + { + var data = line.Substring("data:".Length).Trim(); + if (data.Length > 0) + { + return JsonNode.Parse(data)!; + } + } + } + throw new InvalidOperationException("SSE response did not contain a JSON data event. Body: " + body); + } + + return JsonNode.Parse(body)!; + } + + private static string July2026ProtocolMetaFragment(string protocolVersion = McpProtocolVersions.July2026ProtocolVersion) => + @"""_meta"":{""io.modelcontextprotocol/protocolVersion"":""" + protocolVersion + + @""",""io.modelcontextprotocol/clientInfo"":{""name"":""raw"",""version"":""1.0""}," + + @"""io.modelcontextprotocol/clientCapabilities"":{}}"; + + [Fact] + public async Task July2026ToolsCall_WithFullMeta_Succeeds_200() + { + await StartAsync(); + + var body = + @"{""jsonrpc"":""2.0"",""id"":1,""method"":""tools/call"",""params"":{""name"":""echo"",""arguments"":{""text"":""hi""}," + + July2026ProtocolMetaFragment() + "}}"; + + using var request = new HttpRequestMessage(HttpMethod.Post, "") { Content = JsonContent(body) }; + request.Headers.Add(ProtocolVersionHeader, McpProtocolVersions.July2026ProtocolVersion); + request.Headers.Add("Mcp-Method", "tools/call"); + request.Headers.Add("Mcp-Name", "echo"); + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + var json = await ReadJsonResponseAsync(response, TestContext.Current.CancellationToken); + Assert.Equal("echo:hi", json["result"]!["content"]![0]!["text"]!.GetValue()); + Assert.Equal( + nameof(RawHttpConformanceTests), + json["result"]!["_meta"]![MetaKeys.ServerInfo]!["name"]!.GetValue()); + + // Per SEP-2567, starting with the 2026-07-28 protocol revision Streamable HTTP no longer + // supports sessions: the server MUST NOT issue a Mcp-Session-Id. + Assert.False(response.Headers.Contains("mcp-session-id")); + } + + [Fact] + public async Task ServerDiscover_RawPost_ReturnsDiscoverResult() + { + await StartAsync(); + + var body = @"{""jsonrpc"":""2.0"",""id"":1,""method"":""server/discover"",""params"":{" + July2026ProtocolMetaFragment() + "}}"; + + using var request = new HttpRequestMessage(HttpMethod.Post, "") { Content = JsonContent(body) }; + request.Headers.Add(ProtocolVersionHeader, McpProtocolVersions.July2026ProtocolVersion); + request.Headers.Add("Mcp-Method", "server/discover"); + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + var json = await ReadJsonResponseAsync(response, TestContext.Current.CancellationToken); + var supported = json["result"]!["supportedVersions"]!.AsArray().Select(n => n!.GetValue()).ToList(); + Assert.Equal([McpProtocolVersions.July2026ProtocolVersion], supported); + + // Spec PR #2855 makes ttlMs and cacheScope required on DiscoverResult; the server emits the + // safest defaults (immediately stale, not shareable) when the application hasn't customized. + Assert.Equal(JsonValueKind.Number, json["result"]!["ttlMs"]!.GetValueKind()); + Assert.Equal(0, json["result"]!["ttlMs"]!.GetValue()); + Assert.Equal("private", json["result"]!["cacheScope"]!.GetValue()); + Assert.Null(json["result"]!["serverInfo"]); + Assert.Equal( + nameof(RawHttpConformanceTests), + json["result"]!["_meta"]![MetaKeys.ServerInfo]!["name"]!.GetValue()); + } + + [Fact] + public async Task July2026Post_UnknownMethod_Returns404_WithMethodNotFound() + { + await StartAsync(); + + var body = @"{""jsonrpc"":""2.0"",""id"":17,""method"":""unknown/method"",""params"":{" + July2026ProtocolMetaFragment() + "}}"; + + using var request = new HttpRequestMessage(HttpMethod.Post, "") { Content = JsonContent(body) }; + request.Headers.Add(ProtocolVersionHeader, McpProtocolVersions.July2026ProtocolVersion); + request.Headers.Add("Mcp-Method", "unknown/method"); + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + + Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); + var json = await ReadJsonResponseAsync(response, TestContext.Current.CancellationToken); + Assert.Equal(17, json["id"]!.GetValue()); + Assert.Equal((int)McpErrorCode.MethodNotFound, json["error"]!["code"]!.GetValue()); + } + + [Theory] + [InlineData("initialize")] + [InlineData("ping")] + [InlineData("logging/setLevel")] + [InlineData("resources/subscribe")] + [InlineData("resources/unsubscribe")] + public async Task July2026Post_RemovedMethod_Returns404_WithMethodNotFound(string method) + { + await StartAsync(); + + var body = @"{""jsonrpc"":""2.0"",""id"":18,""method"":""" + method + + @""",""params"":{" + July2026ProtocolMetaFragment() + "}}"; + + using var request = new HttpRequestMessage(HttpMethod.Post, "") { Content = JsonContent(body) }; + request.Headers.Add(ProtocolVersionHeader, McpProtocolVersions.July2026ProtocolVersion); + request.Headers.Add("Mcp-Method", method); + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + + Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); + var json = await ReadJsonResponseAsync(response, TestContext.Current.CancellationToken); + Assert.Equal(18, json["id"]!.GetValue()); + Assert.Equal((int)McpErrorCode.MethodNotFound, json["error"]!["code"]!.GetValue()); + } + + [Fact] + public async Task July2026Post_MissingRequiredCapability_Returns400() + { + await StartAsync(); + + var body = + @"{""jsonrpc"":""2.0"",""id"":19,""method"":""tools/call"",""params"":{""name"":""requires_sampling"",""arguments"":{}," + + July2026ProtocolMetaFragment() + "}}"; + + using var request = new HttpRequestMessage(HttpMethod.Post, "") { Content = JsonContent(body) }; + request.Headers.Add(ProtocolVersionHeader, McpProtocolVersions.July2026ProtocolVersion); + request.Headers.Add("Mcp-Method", "tools/call"); + request.Headers.Add("Mcp-Name", "requires_sampling"); + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + var json = await ReadJsonResponseAsync(response, TestContext.Current.CancellationToken); + Assert.Equal(19, json["id"]!.GetValue()); + Assert.Equal((int)McpErrorCode.MissingRequiredClientCapability, json["error"]!["code"]!.GetValue()); + } + + [Fact] + public async Task ServerDiscover_WithConfiguredPerRequestMetadataProtocol_ReturnsOnlyConfiguredVersion() + { + await StartAsync(McpProtocolVersions.July2026ProtocolVersion); + + var body = @"{""jsonrpc"":""2.0"",""id"":1,""method"":""server/discover"",""params"":{" + July2026ProtocolMetaFragment() + "}}"; + + using var request = new HttpRequestMessage(HttpMethod.Post, "") { Content = JsonContent(body) }; + request.Headers.Add(ProtocolVersionHeader, McpProtocolVersions.July2026ProtocolVersion); + request.Headers.Add("Mcp-Method", "server/discover"); + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + var json = await ReadJsonResponseAsync(response, TestContext.Current.CancellationToken); + var supported = json["result"]!["supportedVersions"]!.AsArray().Select(n => n!.GetValue()).ToList(); + Assert.Equal([McpProtocolVersions.July2026ProtocolVersion], supported); + } + + [Fact] + public async Task July2026Post_WithUnsupportedProtocolVersionHeader_Returns400_With_Minus32022() + { + await StartAsync(); + + var body = + @"{""jsonrpc"":""2.0"",""id"":1,""method"":""tools/call"",""params"":{""name"":""echo"",""arguments"":{""text"":""x""}," + + July2026ProtocolMetaFragment("9999-99-99") + "}}"; + + using var request = new HttpRequestMessage(HttpMethod.Post, "") { Content = JsonContent(body) }; + request.Headers.Add(ProtocolVersionHeader, "9999-99-99"); + request.Headers.Add("Mcp-Method", "tools/call"); + request.Headers.Add("Mcp-Name", "echo"); + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + + // Per spec/streamable-http.mdx the server MUST return 400 Bad Request with -32022 and a data payload + // listing the supported versions. The dual-path client uses this to switch versions without fallback. + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + var json = await ReadJsonResponseAsync(response, TestContext.Current.CancellationToken); + Assert.Equal((int)McpErrorCode.UnsupportedProtocolVersion, json["error"]!["code"]!.GetValue()); + + var data = json["error"]!["data"]; + Assert.NotNull(data); + Assert.Equal("9999-99-99", data!["requested"]!.GetValue()); + var supported = data["supported"]!.AsArray().Select(n => n!.GetValue()).ToList(); + Assert.Equal([McpProtocolVersions.July2026ProtocolVersion], supported); + } + + [Fact] + public async Task July2026Post_ProtocolVersionHeaderMetaMismatch_ReturnsHeaderMismatch_Minus32020() + { + await StartAsync(); + + // The MCP-Protocol-Version header declares the 2026-07-28 protocol revision, but the per-request _meta declares a + // different (still individually supported) version. Per SEP-2575 the server MUST reject the + // disagreement. It uses -32020 HeaderMismatch (the same code as the Mcp-Method/Mcp-Name header-vs-body + // checks) so a conformant client on this revision surfaces the error instead of mistaking the + // per-request-metadata server for an initialize-handshake one and falling back to initialize. + var body = + @"{""jsonrpc"":""2.0"",""id"":4242,""method"":""server/discover"",""params"":{" + + July2026ProtocolMetaFragment("2025-11-25") + "}}"; + + using var request = new HttpRequestMessage(HttpMethod.Post, "") { Content = JsonContent(body) }; + request.Headers.Add(ProtocolVersionHeader, McpProtocolVersions.July2026ProtocolVersion); + request.Headers.Add("Mcp-Method", "server/discover"); + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + var json = await ReadJsonResponseAsync(response, TestContext.Current.CancellationToken); + Assert.Equal((int)McpErrorCode.HeaderMismatch, json["error"]!["code"]!.GetValue()); + + // The body parsed successfully, so per the base protocol responses section (and SEP-2243's error + // response format) this error MUST echo the request id rather than emitting id=null (see #1677). + Assert.Equal(4242, json["id"]!.GetValue()); + } + + [Fact] + public async Task July2026Post_MissingMcpNameHeader_ReturnsHeaderMismatch_EchoesRequestId() + { + await StartAsync(); + + // A well-formed tools/call whose body parses, but the required Mcp-Name header is absent. The server + // rejects it with -32020 HeaderMismatch, and because the request id was readable the JSON-RPC error + // MUST carry that same id (regression guard for #1677). + var body = + @"{""jsonrpc"":""2.0"",""id"":4242,""method"":""tools/call"",""params"":{""name"":""echo"",""arguments"":{""text"":""hi""}," + + July2026ProtocolMetaFragment() + "}}"; + + using var request = new HttpRequestMessage(HttpMethod.Post, "") { Content = JsonContent(body) }; + request.Headers.Add(ProtocolVersionHeader, McpProtocolVersions.July2026ProtocolVersion); + request.Headers.Add("Mcp-Method", "tools/call"); + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + var json = await ReadJsonResponseAsync(response, TestContext.Current.CancellationToken); + Assert.Equal((int)McpErrorCode.HeaderMismatch, json["error"]!["code"]!.GetValue()); + Assert.Equal(4242, json["id"]!.GetValue()); + } + + [Fact] + public async Task July2026Post_WithServerPinnedToInitializeHandshakeVersion_ReturnsUnsupportedProtocolVersion() + { + await StartAsync(McpProtocolVersions.November2025ProtocolVersion); + + var body = + @"{""jsonrpc"":""2.0"",""id"":1,""method"":""tools/call"",""params"":{""name"":""echo"",""arguments"":{""text"":""x""}," + + July2026ProtocolMetaFragment() + "}}"; + + using var request = new HttpRequestMessage(HttpMethod.Post, "") { Content = JsonContent(body) }; + request.Headers.Add(ProtocolVersionHeader, McpProtocolVersions.July2026ProtocolVersion); + request.Headers.Add("Mcp-Method", "tools/call"); + request.Headers.Add("Mcp-Name", "echo"); + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + var json = await ReadJsonResponseAsync(response, TestContext.Current.CancellationToken); + Assert.Equal((int)McpErrorCode.UnsupportedProtocolVersion, json["error"]!["code"]!.GetValue()); + Assert.Equal(McpProtocolVersions.July2026ProtocolVersion, json["error"]!["data"]!["requested"]!.GetValue()); + + var supported = json["error"]!["data"]!["supported"]!.AsArray().Select(n => n!.GetValue()).ToList(); + Assert.Equal([McpProtocolVersions.November2025ProtocolVersion], supported); + } + + [Fact] + public async Task July2026Post_MissingBodyProtocolVersion_ReturnsInvalidParams_Minus32602() + { + await StartAsync(); + + var body = @"{""jsonrpc"":""2.0"",""id"":1,""method"":""server/discover"",""params"":{""_meta"":{""io.modelcontextprotocol/clientInfo"":{""name"":""raw"",""version"":""1.0""},""io.modelcontextprotocol/clientCapabilities"":{}}}}"; + + using var request = new HttpRequestMessage(HttpMethod.Post, "") { Content = JsonContent(body) }; + request.Headers.Add(ProtocolVersionHeader, McpProtocolVersions.July2026ProtocolVersion); + request.Headers.Add("Mcp-Method", "server/discover"); + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + + // A missing (rather than mismatched) _meta protocol version is an Invalid params rejection + // per SEP-2575; -32020 HeaderMismatch is reserved for values present on both sides that + // disagree. + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + var json = await ReadJsonResponseAsync(response, TestContext.Current.CancellationToken); + Assert.Equal((int)McpErrorCode.InvalidParams, json["error"]!["code"]!.GetValue()); + Assert.Contains(MetaKeys.ProtocolVersion, json["error"]!["message"]!.GetValue(), StringComparison.Ordinal); + } + + [Fact] + public async Task July2026Post_MissingProtocolVersionHeader_ReturnsHeaderMismatch_Minus32020() + { + await StartAsync(); + + var body = @"{""jsonrpc"":""2.0"",""id"":1,""method"":""server/discover"",""params"":{" + July2026ProtocolMetaFragment() + "}}"; + + using var request = new HttpRequestMessage(HttpMethod.Post, "") { Content = JsonContent(body) }; + request.Headers.Add("Mcp-Method", "server/discover"); + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + var json = await ReadJsonResponseAsync(response, TestContext.Current.CancellationToken); + Assert.Equal((int)McpErrorCode.HeaderMismatch, json["error"]!["code"]!.GetValue()); + Assert.Contains(ProtocolVersionHeader, json["error"]!["message"]!.GetValue(), StringComparison.Ordinal); + } + + [Fact] + public async Task Initialize_WithPerRequestMetadataProtocolHeaderAndInitializeBody_ReturnsHeaderMismatch_Minus32020() + { + await StartAsync(); + + var body = @"{""jsonrpc"":""2.0"",""id"":1,""method"":""initialize"",""params"":{""protocolVersion"":""2025-11-25"",""capabilities"":{},""clientInfo"":{""name"":""initialize-handshake"",""version"":""1.0""}}}"; + + using var request = new HttpRequestMessage(HttpMethod.Post, "") { Content = JsonContent(body) }; + request.Headers.Add(ProtocolVersionHeader, McpProtocolVersions.July2026ProtocolVersion); + request.Headers.Add("Mcp-Method", RequestMethods.Initialize); + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + var json = await ReadJsonResponseAsync(response, TestContext.Current.CancellationToken); + Assert.Equal((int)McpErrorCode.HeaderMismatch, json["error"]!["code"]!.GetValue()); + } + + [Fact] + public async Task InitializeHandshake_StillSucceeds_OnDefaultServer() + { + await StartAsync(); + + var body = @"{""jsonrpc"":""2.0"",""id"":1,""method"":""initialize"",""params"":{""protocolVersion"":""2025-11-25"",""capabilities"":{},""clientInfo"":{""name"":""initialize-handshake"",""version"":""1.0""}}}"; + + using var request = new HttpRequestMessage(HttpMethod.Post, "") { Content = JsonContent(body) }; + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + var json = await ReadJsonResponseAsync(response, TestContext.Current.CancellationToken); + Assert.Equal("2025-11-25", json["result"]!["protocolVersion"]!.GetValue()); + + // resultType is a 2026-07-28 result field, and the initialize handshake only ever negotiates + // 2025-11-25 or earlier. It must not appear on the InitializeResult, or strict 2025-11-25 clients + // reject the handshake (issue #1721). + Assert.False(json["result"]!.AsObject().ContainsKey("resultType"), + "InitializeResult must not carry resultType on a 2025-11-25 handshake."); + } + + [Fact] + public async Task DownlevelToolsList_On2025_11_25_OmitsResultTypeAndCacheHints() + { + await StartAsync(); + + // A 2025-11-25 client completes the initialize handshake and then sends subsequent requests with + // the MCP-Protocol-Version header pinned to the negotiated revision. The server must not decorate + // the result with the 2026-07-28-exclusive resultType/ttlMs/cacheScope fields (issue #1721). + var initBody = @"{""jsonrpc"":""2.0"",""id"":1,""method"":""initialize"",""params"":{""protocolVersion"":""2025-11-25"",""capabilities"":{},""clientInfo"":{""name"":""initialize-handshake"",""version"":""1.0""}}}"; + using (var initRequest = new HttpRequestMessage(HttpMethod.Post, "") { Content = JsonContent(initBody) }) + using (var initResponse = await HttpClient.SendAsync(initRequest, TestContext.Current.CancellationToken)) + { + Assert.Equal(HttpStatusCode.OK, initResponse.StatusCode); + } + + var body = @"{""jsonrpc"":""2.0"",""id"":2,""method"":""tools/list"",""params"":{}}"; + using var request = new HttpRequestMessage(HttpMethod.Post, "") { Content = JsonContent(body) }; + request.Headers.Add(ProtocolVersionHeader, McpProtocolVersions.November2025ProtocolVersion); + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + var json = await ReadJsonResponseAsync(response, TestContext.Current.CancellationToken); + var result = json["result"]!.AsObject(); + Assert.False(result.ContainsKey("resultType"), "resultType must be absent on a 2025-11-25 tools/list result."); + Assert.False(result.ContainsKey("ttlMs"), "ttlMs must be absent on a 2025-11-25 tools/list result."); + Assert.False(result.ContainsKey("cacheScope"), "cacheScope must be absent on a 2025-11-25 tools/list result."); + } + + [Fact] + public async Task GetEndpoint_NotMapped_UnderDefaultStatelessConfiguration_Returns405() + { + await StartAsync(); + + using var request = new HttpRequestMessage(HttpMethod.Get, ""); + request.Headers.Accept.Add(new("text/event-stream")); + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + + // SessionMode = HttpServerSessionMode.Stateless doesn't map the GET endpoint - per SEP-2567 the standalone SSE + // stream is replaced by subscriptions/listen POST requests. Existing routing in + // McpEndpointRouteBuilderExtensions only maps GET when Stateless == false. + Assert.Equal(HttpStatusCode.MethodNotAllowed, response.StatusCode); + } + + [Fact] + public async Task July2026Post_MissingClientCapabilities_Returns400_WithInvalidParams() + { + await StartAsync(); + + var body = + @"{""jsonrpc"":""2.0"",""id"":20,""method"":""server/discover"",""params"":{""_meta"":{" + + @"""io.modelcontextprotocol/protocolVersion"":""" + McpProtocolVersions.July2026ProtocolVersion + @"""}}}"; + + using var request = new HttpRequestMessage(HttpMethod.Post, "") { Content = JsonContent(body) }; + request.Headers.Add(ProtocolVersionHeader, McpProtocolVersions.July2026ProtocolVersion); + request.Headers.Add("Mcp-Method", "server/discover"); + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + var json = await ReadJsonResponseAsync(response, TestContext.Current.CancellationToken); + Assert.Equal(20, json["id"]!.GetValue()); + Assert.Equal((int)McpErrorCode.InvalidParams, json["error"]!["code"]!.GetValue()); + Assert.Contains(MetaKeys.ClientCapabilities, json["error"]!["message"]!.GetValue(), StringComparison.Ordinal); + } + + [Theory] + [InlineData("5")] + [InlineData("\"caps\"")] + [InlineData("[]")] + [InlineData("true")] + public async Task July2026Post_MalformedClientCapabilities_Returns400_WithInvalidParams(string clientCapabilitiesJson) + { + await StartAsync(); + + var body = + @"{""jsonrpc"":""2.0"",""id"":21,""method"":""server/discover"",""params"":{""_meta"":{" + + @"""io.modelcontextprotocol/protocolVersion"":""" + McpProtocolVersions.July2026ProtocolVersion + @"""," + + @"""io.modelcontextprotocol/clientInfo"":{""name"":""raw"",""version"":""1.0""}," + + @"""io.modelcontextprotocol/clientCapabilities"":" + clientCapabilitiesJson + "}}}"; + + using var request = new HttpRequestMessage(HttpMethod.Post, "") { Content = JsonContent(body) }; + request.Headers.Add(ProtocolVersionHeader, McpProtocolVersions.July2026ProtocolVersion); + request.Headers.Add("Mcp-Method", "server/discover"); + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + + // A present-but-wrong-shape clientCapabilities must be rejected up front with -32602 / 400, + // not surface later as a generic internal error on a 200 response. + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + var json = await ReadJsonResponseAsync(response, TestContext.Current.CancellationToken); + Assert.Equal(21, json["id"]!.GetValue()); + Assert.Equal((int)McpErrorCode.InvalidParams, json["error"]!["code"]!.GetValue()); + Assert.Contains(MetaKeys.ClientCapabilities, json["error"]!["message"]!.GetValue(), StringComparison.Ordinal); + } + + [McpServerToolType] + private sealed class CapabilityTools + { + [McpServerTool(Name = "requires_sampling")] + public static string RequiresSampling() => + throw new MissingRequiredClientCapabilityException( + new ClientCapabilities { Sampling = new() }, + "sampling capability required but not declared by client"); + } +} diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/RequestAbortCancellationTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/RequestAbortCancellationTests.cs new file mode 100644 index 000000000..166622d74 --- /dev/null +++ b/tests/ModelContextProtocol.AspNetCore.Tests/RequestAbortCancellationTests.cs @@ -0,0 +1,159 @@ +using Microsoft.AspNetCore.Builder; +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.AspNetCore.Tests.Utils; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using ModelContextProtocol.Tests.Utils; +using System.Net.Http.Headers; +using System.Text; + +namespace ModelContextProtocol.AspNetCore.Tests; + +/// +/// Verifies that aborting an HTTP request flows cancellation into the running request handler's +/// . +/// +/// Starting with the 2026-07-28 protocol revision (SEP-2575 + SEP-2567) the HTTP request lifetime is the +/// request lifetime: there are no sessions, so a dropped connection is equivalent to cancelling the +/// in-flight request. The same holds for legacy stateless mode, where each request is independent and +/// outlived by nothing. These tests pin that behavior so a tool's fires +/// promptly when the client goes away. +/// +/// +public class RequestAbortCancellationTests(ITestOutputHelper outputHelper) : KestrelInMemoryTest(outputHelper), IAsyncDisposable +{ + + private WebApplication? _app; + + private readonly TaskCompletionSource _toolStarted = new(TaskCreationOptions.RunContinuationsAsynchronously); + private readonly TaskCompletionSource _toolCanceled = new(TaskCreationOptions.RunContinuationsAsynchronously); + private readonly TaskCompletionSource _requestAborted = new(TaskCreationOptions.RunContinuationsAsynchronously); + + private async Task StartAsync(bool stateless) + { + Builder.Services.AddMcpServer(options => + { + options.ServerInfo = new Implementation { Name = nameof(RequestAbortCancellationTests), Version = "1" }; + }) + .WithHttpTransport(options => options.Stateless = stateless) + .WithTools([McpServerTool.Create( + async (CancellationToken cancellationToken) => + { + _toolStarted.TrySetResult(); + try + { + // Block until the request handler's CancellationToken fires. If cancellation never + // flows from the aborted HTTP request, this hangs and the test times out. + await Task.Delay(Timeout.Infinite, cancellationToken); + } + catch (OperationCanceledException) + { + _toolCanceled.TrySetResult(); + throw; + } + + return "unreachable"; + }, + new() { Name = "blockingTool" })]); + + _app = Builder.Build(); + + // Record when the server observes the client abort so we can assert the abort (not some unrelated + // cancellation path) is what tears down the in-flight tool. + _app.Use(async (context, next) => + { + context.RequestAborted.Register(() => _requestAborted.TrySetResult()); + await next(); + }); + + _app.MapMcp(); + await _app.StartAsync(TestContext.Current.CancellationToken); + } + + public async ValueTask DisposeAsync() + { + if (_app is not null) + { + await _app.DisposeAsync(); + } + base.Dispose(); + } + + [Fact] + public async Task July2026Request_AbortFlowsCancellationToToolHandler() + { + // Starting with the 2026-07-28 protocol revision, Streamable HTTP no longer supports sessions (SEP-2567) and is + // served natively only on a stateless server; a stateful server refuses these requests to allow + // a client to fall back to `initialize` if it supports it. + await StartAsync(stateless: true); + + using var request = CreateBlockingToolRequest(july2026Protocol: true); + + await AssertAbortCancelsToolAsync(request); + } + + [Fact] + public async Task StatelessRequest_AbortFlowsCancellationToToolHandler() + { + await StartAsync(stateless: true); + + using var request = CreateBlockingToolRequest(july2026Protocol: false); + + await AssertAbortCancelsToolAsync(request); + } + + private static HttpRequestMessage CreateBlockingToolRequest(bool july2026Protocol) + { + // A 2026-07-28 tools/call requires the SEP-2243 Mcp-Method/Mcp-Name headers and the per-request _meta + // (protocol version, client info, capabilities) that replaces the initialize handshake (SEP-2567). + var body = july2026Protocol + ? """ + {"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"blockingTool","_meta":{"io.modelcontextprotocol/protocolVersion":"PROTOCOL_VERSION","io.modelcontextprotocol/clientInfo":{"name":"raw","version":"1.0"},"io.modelcontextprotocol/clientCapabilities":{}}}} + """.Replace("PROTOCOL_VERSION", McpProtocolVersions.July2026ProtocolVersion) + : """{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"blockingTool"}}"""; + + var request = new HttpRequestMessage(HttpMethod.Post, "") + { + Content = new StringContent(body, Encoding.UTF8, "application/json"), + }; + + request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); + request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("text/event-stream")); + + if (july2026Protocol) + { + request.Headers.Add("MCP-Protocol-Version", McpProtocolVersions.July2026ProtocolVersion); + request.Headers.Add("Mcp-Method", "tools/call"); + request.Headers.Add("Mcp-Name", "blockingTool"); + } + + return request; + } + + private async Task AssertAbortCancelsToolAsync(HttpRequestMessage request) + { + using var requestCts = new CancellationTokenSource(); + + // Send the request without awaiting completion. The blockingTool will not return until its + // CancellationToken fires, so this Task only completes once we abort the request below. + // ResponseContentRead (the default) keeps SendAsync pending on the response body, so cancelling + // requestCts actually aborts the in-flight connection. (With ResponseHeadersRead, SendAsync would + // return as soon as the server flushed the SSE response headers and the cancel would be a no-op.) + var sendTask = HttpClient.SendAsync(request, requestCts.Token); + + // Wait for the server to actually start running the tool before aborting. + await _toolStarted.Task.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); + + // Abort the in-flight HTTP request, simulating the client disconnecting. + requestCts.Cancel(); + + // The server must observe the abort... + await _requestAborted.Task.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); + + // ...and that abort must cancel the running tool's CancellationToken. + await _toolCanceled.Task.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); + + // The HttpClient call itself should observe the cancellation we requested. + await Assert.ThrowsAnyAsync(() => sendTask); + } +} diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/ResumabilityIntegrationTestsBase.cs b/tests/ModelContextProtocol.AspNetCore.Tests/ResumabilityIntegrationTestsBase.cs index 9738ffda3..87218202f 100644 --- a/tests/ModelContextProtocol.AspNetCore.Tests/ResumabilityIntegrationTestsBase.cs +++ b/tests/ModelContextProtocol.AspNetCore.Tests/ResumabilityIntegrationTestsBase.cs @@ -490,6 +490,8 @@ protected async Task CreateServerAsync( var serverBuilder = Builder.Services.AddMcpServer() .WithHttpTransport(options => { + // Resumability is a stateful concern; pin SessionMode = HttpServerSessionMode.Stateful since the session is required. + options.SessionMode = HttpServerSessionMode.Stateful; options.EventStreamStore = eventStreamStore; configureTransport?.Invoke(options); }) @@ -515,7 +517,11 @@ protected async Task ConnectClientAsync() TransportMode = HttpTransportMode.StreamableHttp, }, HttpClient, LoggerFactory); - return await McpClient.CreateAsync(transport, loggerFactory: LoggerFactory, + // Resumability (Last-Event-ID) and Mcp-Session-Id are removed in the 2026-07-28 protocol + // revision (SEP-2567). Pin the client to the latest stable version so it negotiates the stateful, + // resumable legacy handshake instead of the 2026-07-28 default. + return await McpClient.CreateAsync(transport, new McpClientOptions { ProtocolVersion = "2025-11-25" }, + loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); } diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/ServerConformanceTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/ServerConformanceTests.cs index adb8e4ac4..2cb1d736e 100644 --- a/tests/ModelContextProtocol.AspNetCore.Tests/ServerConformanceTests.cs +++ b/tests/ModelContextProtocol.AspNetCore.Tests/ServerConformanceTests.cs @@ -1,199 +1,173 @@ -using System.Diagnostics; -using System.Runtime.InteropServices; -using System.Text; using ModelContextProtocol.Tests.Utils; namespace ModelContextProtocol.ConformanceTests; /// -/// Shared fixture that starts a single ConformanceServer instance for all tests in -/// . This avoids TCP port TIME_WAIT conflicts -/// that occur when each test starts and stops its own server on the same port. +/// Runs the official MCP conformance tests against the ConformanceServer. Uses a shared +/// so the server is started once and reused across all +/// tests, avoiding TCP port conflicts on Windows. Stateful scenarios use the server's "/" endpoint +/// (); 2026-07-28 scenarios that negotiate the +/// stateless lifecycle use its "/stateless" endpoint +/// (). /// -public class ConformanceServerFixture : IAsyncLifetime +[Collection(nameof(ConformanceServerCollection))] +public class ServerConformanceTests( + ConformanceServerFixture fixture, + ITestOutputHelper output) { - // Use different ports for each target framework to allow parallel execution - // net10.0 -> 3001, net9.0 -> 3002, net8.0 -> 3003 - private static int GetPortForTargetFramework() + [Fact] + public async Task RunConformanceTests() { - var testBinaryDir = AppContext.BaseDirectory; - var targetFramework = Path.GetFileName(testBinaryDir.TrimEnd(Path.DirectorySeparatorChar)); - - return targetFramework switch - { - "net10.0" => 3001, - "net9.0" => 3002, - "net8.0" => 3003, - _ => 3001 // Default fallback - }; - } - - private Task? _serverTask; - private CancellationTokenSource? _serverCts; + Assert.SkipWhen(!NodeHelpers.IsNodeInstalled(), "Node.js is not installed. Skipping conformance tests."); - public string ServerUrl { get; } = $"http://localhost:{GetPortForTargetFramework()}"; + var result = await RunConformanceTestsAsync($"server --url {fixture.ServerUrl}"); - public async ValueTask InitializeAsync() - { - _serverCts = new CancellationTokenSource(); - _serverTask = Task.Run(() => ConformanceServer.Program.MainAsync( - ["--urls", ServerUrl], cancellationToken: _serverCts.Token)); - - // Wait for server to be ready (retry for up to 30 seconds) - var timeout = TimeSpan.FromSeconds(30); - var stopwatch = Stopwatch.StartNew(); - using var httpClient = new HttpClient { Timeout = TestConstants.HttpClientPollingTimeout }; - - while (stopwatch.Elapsed < timeout) - { - try - { - await httpClient.GetAsync($"{ServerUrl}/health"); - return; - } - catch (HttpRequestException) - { - // Connection refused means server not ready yet - } - catch (TaskCanceledException) - { - // Timeout means server might be processing, give it more time - } - - await Task.Delay(500); - } - - throw new InvalidOperationException("ConformanceServer failed to start within the timeout period"); + Assert.True(result.Success, + $"Conformance tests failed.\n\nStdout:\n{result.Output}\n\nStderr:\n{result.Error}"); } - public async ValueTask DisposeAsync() + [Fact] + public async Task RunConformanceTest_JsonSchema202012() { - if (_serverCts != null) - { - _serverCts.Cancel(); - if (_serverTask != null) - { - try - { - await _serverTask.WaitAsync(TestConstants.DefaultTimeout); - } - catch - { - // Ignore exceptions during shutdown - } - } - _serverCts.Dispose(); - } + Assert.SkipWhen(!NodeHelpers.IsNodeInstalled(), "Node.js is not installed. Skipping conformance tests."); + + var result = await RunConformanceTestsAsync($"server --url {fixture.ServerUrl} --scenario json-schema-2020-12"); + + Assert.True(result.Success, + $"Conformance test failed.\n\nStdout:\n{result.Output}\n\nStderr:\n{result.Error}"); } -} -/// -/// Runs the official MCP conformance tests against the ConformanceServer. -/// Uses a shared so the server is started once -/// and reused across all tests, avoiding TCP port conflicts on Windows. -/// -public class ServerConformanceTests(ConformanceServerFixture fixture, ITestOutputHelper output) - : IClassFixture -{ [Fact] - public async Task RunConformanceTests() + public async Task RunConformanceTest_ServerSsePolling() { Assert.SkipWhen(!NodeHelpers.IsNodeInstalled(), "Node.js is not installed. Skipping conformance tests."); - var result = await RunConformanceTestsAsync($"server --url {fixture.ServerUrl}"); + var result = await RunConformanceTestsAsync($"server --url {fixture.ServerUrl} --scenario server-sse-polling"); Assert.True(result.Success, - $"Conformance tests failed.\n\nStdout:\n{result.Output}\n\nStderr:\n{result.Error}"); + $"Conformance test failed.\n\nStdout:\n{result.Output}\n\nStderr:\n{result.Error}"); } [Fact] - public async Task RunPendingConformanceTest_JsonSchema202012() + public async Task RunConformanceTest_HttpHeaderValidation() { Assert.SkipWhen(!NodeHelpers.IsNodeInstalled(), "Node.js is not installed. Skipping conformance tests."); Assert.SkipWhen( - RuntimeInformation.IsOSPlatform(OSPlatform.Windows), - "Pending Node-based conformance scenario is unstable on Windows due to a libuv shutdown assertion."); + !NodeHelpers.HasSep2243Scenarios(), + "SEP-2243 conformance scenarios are not available in the installed conformance package."); - var result = await RunConformanceTestsAsync($"server --url {fixture.ServerUrl} --scenario json-schema-2020-12"); + // SEP-2243 is a 2026-07-28 protocol revision scenario that uses the stateless lifecycle, + // so it runs against the shared server's stateless endpoint (a stateful server rejects the + // un-initialized list/call requests with JSON-RPC -32000). + var result = await RunStatelessConformanceTestAsync( + $"server --url {fixture.StatelessServerUrl} --scenario http-header-validation --spec-version 2026-07-28"); Assert.True(result.Success, $"Conformance test failed.\n\nStdout:\n{result.Output}\n\nStderr:\n{result.Error}"); } [Fact] - public async Task RunPendingConformanceTest_ServerSsePolling() + public async Task RunConformanceTest_HttpCustomHeaderServerValidation() { Assert.SkipWhen(!NodeHelpers.IsNodeInstalled(), "Node.js is not installed. Skipping conformance tests."); Assert.SkipWhen( - RuntimeInformation.IsOSPlatform(OSPlatform.Windows), - "Pending Node-based conformance scenario is unstable on Windows due to a libuv shutdown assertion."); + !NodeHelpers.HasSep2243Scenarios(), + "SEP-2243 conformance scenarios are not available in the installed conformance package."); - var result = await RunConformanceTestsAsync($"server --url {fixture.ServerUrl} --scenario server-sse-polling"); + var result = await RunStatelessConformanceTestAsync( + $"server --url {fixture.StatelessServerUrl} --scenario http-custom-header-server-validation --spec-version 2026-07-28"); Assert.True(result.Success, $"Conformance test failed.\n\nStdout:\n{result.Output}\n\nStderr:\n{result.Error}"); } + // SEP-2322 (Multi Round-Trip Requests / InputRequiredResult) conformance scenarios. + // The csharp-sdk ConformanceServer surfaces the matching tools/prompts via + // ConformanceServer.Tools.IncompleteResultTools and ConformanceServer.Prompts.IncompleteResultPrompts + // (the class names predate the conformance-suite rename from "incomplete-result-*" to + // "input-required-result-*"; the wire-level tool names now match the new convention). + // Each scenario uses the conformance harness's RawMcpSession, which negotiates 2026-07-28, + // so the csharp-sdk emits InputRequiredResult on the wire. Because the 2026-07-28 revision is + // served only on a stateless server, the scenarios run against the shared server's stateless + // endpoint (ConformanceServerFixture.StatelessServerUrl); a stateful server refuses these requests. + // These tests skip until the installed conformance package ships SEP-2322 scenarios + // (see ). + // + // input-required-result-tampered-state and input-required-result-capability-check are + // implemented by ConformanceServer.Tools.IncompleteResultTools.ToolWithTamperedState + // (HMAC-protected requestState; a tampered requestState surfaces a -32602 JSON-RPC error) + // and ToolWithCapabilityCheck (gates inputRequests on the per-request + // _meta clientCapabilities envelope). Both behaviors also have in-process wire-level + // regression coverage in MrtrProtocolTests so they stay verified independent of the + // published conformance package. + [Theory] + [InlineData("input-required-result-basic-elicitation")] + [InlineData("input-required-result-basic-sampling")] + [InlineData("input-required-result-basic-list-roots")] + [InlineData("input-required-result-request-state")] + [InlineData("input-required-result-multiple-input-requests")] + [InlineData("input-required-result-multi-round")] + [InlineData("input-required-result-missing-input-response")] + [InlineData("input-required-result-non-tool-request")] + [InlineData("input-required-result-result-type")] + [InlineData("input-required-result-unsupported-methods")] + [InlineData("input-required-result-tampered-state")] + [InlineData("input-required-result-capability-check")] + [InlineData("input-required-result-ignore-extra-params")] + [InlineData("input-required-result-validate-input")] + public async Task RunMrtrConformanceTest(string scenario) + { + Assert.SkipWhen(!NodeHelpers.IsNodeInstalled(), "Node.js is not installed. Skipping conformance tests."); + Assert.SkipWhen(!NodeHelpers.HasMrtrScenarios(), "SEP-2322 MRTR conformance scenarios are not available in the installed conformance package."); + + var result = await RunStatelessConformanceTestAsync( + $"server --url {fixture.StatelessServerUrl} --scenario {scenario} --spec-version 2026-07-28"); + + Assert.True(result.Success, + $"MRTR conformance test '{scenario}' failed.\n\nStdout:\n{result.Output}\n\nStderr:\n{result.Error}"); + } + + [Theory] + [InlineData("tasks-wire-fields")] + [InlineData("tasks-lifecycle")] + [InlineData("tasks-capability-negotiation")] + [InlineData("tasks-request-headers")] + [InlineData("tasks-dispatch-and-envelope")] + [InlineData("tasks-status-notifications")] + [InlineData("tasks-required-task-error")] + [InlineData("tasks-request-state-removal")] + [InlineData("tasks-mrtr-input")] + [InlineData("tasks-mrtr-composition")] + public async Task RunTasksExtensionConformanceTest(string scenario) + { + Assert.SkipWhen(!NodeHelpers.IsNodeInstalled(), "Node.js is not installed. Skipping conformance tests."); + Assert.SkipWhen( + !NodeHelpers.HasTasksExtensionScenarios(), + "SEP-2663 Tasks extension scenarios are not available in the installed conformance package."); + + var result = await RunStatelessConformanceTestAsync( + $"server --url {fixture.StatelessServerUrl} --scenario {scenario}"); + + Assert.True(result.Success, + $"Tasks extension conformance test '{scenario}' failed.\n\nStdout:\n{result.Output}\n\nStderr:\n{result.Error}"); + } + private async Task<(bool Success, string Output, string Error)> RunConformanceTestsAsync(string arguments) { - var startInfo = NodeHelpers.ConformanceTestStartInfo(arguments); - - var outputBuilder = new StringBuilder(); - var errorBuilder = new StringBuilder(); - - var process = new Process { StartInfo = startInfo }; - - // Protect callbacks with try/catch to prevent ITestOutputHelper from - // throwing on a background thread if events arrive after the test completes. - DataReceivedEventHandler outputHandler = (sender, e) => - { - if (e.Data != null) - { - try { output.WriteLine(e.Data); } catch { } - outputBuilder.AppendLine(e.Data); - } - }; - - DataReceivedEventHandler errorHandler = (sender, e) => - { - if (e.Data != null) - { - try { output.WriteLine(e.Data); } catch { } - errorBuilder.AppendLine(e.Data); - } - }; - - process.OutputDataReceived += outputHandler; - process.ErrorDataReceived += errorHandler; - - process.Start(); - process.BeginOutputReadLine(); - process.BeginErrorReadLine(); - - using var cts = new CancellationTokenSource(TimeSpan.FromMinutes(5)); - try - { - await process.WaitForExitAsync(cts.Token); - } - catch (OperationCanceledException) - { - process.Kill(entireProcessTree: true); - process.OutputDataReceived -= outputHandler; - process.ErrorDataReceived -= errorHandler; - return ( - Success: false, - Output: outputBuilder.ToString(), - Error: errorBuilder.ToString() + "\nProcess timed out after 5 minutes and was killed." - ); - } - - process.OutputDataReceived -= outputHandler; - process.ErrorDataReceived -= errorHandler; - - return ( - Success: process.ExitCode == 0, - Output: outputBuilder.ToString(), - Error: errorBuilder.ToString() - ); + return await NodeHelpers.RunServerConformanceAsync( + arguments, + line => { try { output.WriteLine(line); } catch { } }, + cancellationToken: TestContext.Current.CancellationToken); + } + + // For 2026-07-28 protocol scenarios that pin --spec-version explicitly, suppress the + // MCP_CONFORMANCE_PROTOCOL_VERSION override so a duplicate --spec-version is not appended. + private async Task<(bool Success, string Output, string Error)> RunStatelessConformanceTestAsync(string arguments) + { + return await NodeHelpers.RunServerConformanceAsync( + arguments, + line => { try { output.WriteLine(line); } catch { } }, + appendProtocolVersionFromEnv: false, + cancellationToken: TestContext.Current.CancellationToken); } } diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/SessionMigrationTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/SessionMigrationTests.cs index a06a5d129..56fe09bb7 100644 --- a/tests/ModelContextProtocol.AspNetCore.Tests/SessionMigrationTests.cs +++ b/tests/ModelContextProtocol.AspNetCore.Tests/SessionMigrationTests.cs @@ -222,7 +222,7 @@ private async Task StartAsync(ISessionMigrationHandler? migrationHandler = null) Name = "SessionMigrationTestServer", Version = "1.0.0", }; - }).WithTools(Tools).WithHttpTransport(); + }).WithTools(Tools).WithHttpTransport(options => options.SessionMode = HttpServerSessionMode.Stateful); if (migrationHandler is not null) { diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/SseIntegrationTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/SseIntegrationTests.cs index 800a6ce96..bd47bdb74 100644 --- a/tests/ModelContextProtocol.AspNetCore.Tests/SseIntegrationTests.cs +++ b/tests/ModelContextProtocol.AspNetCore.Tests/SseIntegrationTests.cs @@ -1,4 +1,4 @@ -using Microsoft.AspNetCore.Builder; +using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Routing; using Microsoft.Extensions.DependencyInjection; @@ -31,7 +31,7 @@ private Task ConnectMcpClientAsync(HttpClient? httpClient = null, Htt [Fact] public async Task ConnectAndReceiveMessage_InMemoryServer() { - Builder.Services.AddMcpServer().WithHttpTransport(options => options.EnableLegacySse = true); + Builder.Services.AddMcpServer().WithHttpTransport(options => { options.EnableLegacySse = true; options.Stateless = false; }); await using var app = Builder.Build(); app.MapMcp(); await app.StartAsync(TestContext.Current.CancellationToken); @@ -84,6 +84,7 @@ public async Task ConnectAndReceiveNotification_InMemoryServer() .WithHttpTransport(httpTransportOptions => { httpTransportOptions.EnableLegacySse = true; + httpTransportOptions.Stateless = false; #pragma warning disable MCPEXP002 // RunSessionHandler is experimental httpTransportOptions.RunSessionHandler = (httpContext, mcpServer, cancellationToken) => { @@ -128,7 +129,7 @@ public async Task AddMcpServer_CanBeCalled_MultipleTimes() { firstOptionsCallbackCallCount++; }) - .WithHttpTransport(options => options.EnableLegacySse = true) + .WithHttpTransport(options => { options.EnableLegacySse = true; options.Stateless = false; }) .WithTools(); Builder.Services.AddMcpServer(options => @@ -172,7 +173,7 @@ public async Task AddMcpServer_CanBeCalled_MultipleTimes() public async Task AdditionalHeaders_AreSent_InGetAndPostRequests() { Builder.Services.AddMcpServer() - .WithHttpTransport(options => options.EnableLegacySse = true); + .WithHttpTransport(options => { options.EnableLegacySse = true; options.Stateless = false; }); await using var app = Builder.Build(); @@ -219,7 +220,7 @@ public async Task AdditionalHeaders_AreSent_InGetAndPostRequests() public async Task EmptyAdditionalHeadersKey_Throws_InvalidOperationException() { Builder.Services.AddMcpServer() - .WithHttpTransport(options => options.EnableLegacySse = true); + .WithHttpTransport(options => { options.EnableLegacySse = true; options.Stateless = false; }); await using var app = Builder.Build(); @@ -311,7 +312,7 @@ private static void MapAbsoluteEndpointUriMcp(IEndpointRouteBuilder endpoints, b [Fact] public async Task Completion_ServerShutdown_ReturnsHttpCompletionDetails() { - Builder.Services.AddMcpServer().WithHttpTransport(options => options.EnableLegacySse = true); + Builder.Services.AddMcpServer().WithHttpTransport(options => { options.EnableLegacySse = true; options.Stateless = false; }); await using var app = Builder.Build(); app.MapMcp(); await app.StartAsync(TestContext.Current.CancellationToken); diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/StatelessServerTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/StatelessServerTests.cs index 80c37ea61..092f8f256 100644 --- a/tests/ModelContextProtocol.AspNetCore.Tests/StatelessServerTests.cs +++ b/tests/ModelContextProtocol.AspNetCore.Tests/StatelessServerTests.cs @@ -4,8 +4,12 @@ using ModelContextProtocol.Client; using ModelContextProtocol.Protocol; using ModelContextProtocol.Server; +using ModelContextProtocol.Tests.Utils; using System.Diagnostics; using System.Net; +using System.Text.Json; +using System.Text.Json.Nodes; +using System.Threading.Channels; namespace ModelContextProtocol.AspNetCore.Tests; @@ -318,6 +322,254 @@ public async Task StatelessMode_DoesNotAdvertise_ListChangedCapabilities() Assert.Null(client.ServerCapabilities.Resources?.ListChanged); } + [Fact] + public async Task SubscriptionsListen_InStatelessMode_GrantsNothing_AndDoesNotHoldRequestOpen() + { + Builder.Services.AddMcpServer() + .WithHttpTransport(options => + { + options.Stateless = true; + }) + .WithTools([McpServerTool.Create(() => "result", new() { Name = "myTool" })]) + .WithPrompts([McpServerPrompt.Create(() => new GetPromptResult(), new() { Name = "myPrompt" })]) + .WithResources([McpServerResource.Create(() => new ReadResourceResult(), new() { UriTemplate = "resource://test" })]); + + _app = Builder.Build(); + _app.MapMcp(); + await _app.StartAsync(TestContext.Current.CancellationToken); + + HttpClient.DefaultRequestHeaders.Accept.Add(new("application/json")); + HttpClient.DefaultRequestHeaders.Accept.Add(new("text/event-stream")); + + await using var client = await ConnectMcpClientAsync(); + + var ackChannel = Channel.CreateUnbounded(); + await using var ackReg = client.RegisterNotificationHandler(NotificationMethods.SubscriptionsAcknowledgedNotification, + (notification, _) => { ackChannel.Writer.TryWrite(notification); return default; }); + + // Request every kind of subscription the protocol exposes, even though the server registers + // subscribable primitives. A stateless session cannot push out-of-band notifications, so the + // request must acknowledge with no grants and complete promptly instead of holding the POST + // (and its request scope) open forever - a regression would hang here until the timeout. + var listenRequest = new JsonRpcRequest + { + Method = RequestMethods.SubscriptionsListen, + Params = JsonSerializer.SerializeToNode( + new SubscriptionsListenRequestParams + { + Notifications = new SubscriptionsListenNotifications + { + ToolsListChanged = true, + PromptsListChanged = true, + ResourcesListChanged = true, + ResourceSubscriptions = ["resource://test"], + }, + }, + McpJsonUtilities.DefaultOptions), + }; + + await client.SendRequestAsync(listenRequest, TestContext.Current.CancellationToken) + .WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); + + // The acknowledgement is sent before the response completes, so it is already buffered here. + var ack = await ackChannel.Reader.ReadAsync(TestContext.Current.CancellationToken); + var grantedNotifications = Assert.IsType(Assert.IsType(ack.Params)["notifications"]); + Assert.Null(grantedNotifications["toolsListChanged"]); + Assert.Null(grantedNotifications["promptsListChanged"]); + Assert.Null(grantedNotifications["resourcesListChanged"]); + Assert.Null(grantedNotifications["resourceSubscriptions"]); + } + + [Fact] + public async Task SubscriptionsListen_WithCustomHandler_InStatelessMode_StreamsNotificationOverHeldOpenPost() + { + // The built-in stateless handler grants nothing and returns immediately because there is no + // session-wide channel. A custom SubscriptionsListenHandler can instead stream notifications over the + // held-open POST response (the listen request's RelatedTransport), which is the solicited + // server-to-client stream. This is the core scenario of issue #1662. + const string subscribedUri = "resource://test"; + + Builder.Services.AddMcpServer() + .WithHttpTransport(options => + { + options.Stateless = true; + }) + .WithSubscriptionsListenHandler(async (request, cancellationToken) => + { + var subscriptionId = request.JsonRpcRequest.Id; + + var ack = new JsonRpcNotification + { + Method = NotificationMethods.SubscriptionsAcknowledgedNotification, + Params = JsonSerializer.SerializeToNode( + new SubscriptionsAcknowledgedNotificationParams + { + Notifications = new SubscriptionsListenNotifications + { + ResourceSubscriptions = request.Params.Notifications.ResourceSubscriptions, + }, + }, + McpJsonUtilities.DefaultOptions), + }; + TagWithSubscriptionId(ack, subscriptionId); + await request.Server.SendMessageAsync(ack, cancellationToken); + + var updated = new JsonRpcNotification + { + Method = NotificationMethods.ResourceUpdatedNotification, + Params = new JsonObject { ["uri"] = subscribedUri }, + }; + TagWithSubscriptionId(updated, subscriptionId); + await request.Server.SendMessageAsync(updated, cancellationToken); + + // Complete the stream so the POST response finishes; the buffered notifications flush to the client. + return new EmptyResult(); + }); + + _app = Builder.Build(); + _app.MapMcp(); + await _app.StartAsync(TestContext.Current.CancellationToken); + + HttpClient.DefaultRequestHeaders.Accept.Add(new("application/json")); + HttpClient.DefaultRequestHeaders.Accept.Add(new("text/event-stream")); + + await using var client = await ConnectMcpClientAsync(); + + var ackChannel = Channel.CreateUnbounded(); + var updatedChannel = Channel.CreateUnbounded(); + await using var ackReg = client.RegisterNotificationHandler(NotificationMethods.SubscriptionsAcknowledgedNotification, + (notification, _) => { ackChannel.Writer.TryWrite(notification); return default; }); + await using var updatedReg = client.RegisterNotificationHandler(NotificationMethods.ResourceUpdatedNotification, + (notification, _) => { updatedChannel.Writer.TryWrite(notification); return default; }); + + var listenRequest = new JsonRpcRequest + { + Method = RequestMethods.SubscriptionsListen, + Params = JsonSerializer.SerializeToNode( + new SubscriptionsListenRequestParams + { + Notifications = new SubscriptionsListenNotifications { ResourceSubscriptions = [subscribedUri] }, + }, + McpJsonUtilities.DefaultOptions), + }; + + await client.SendRequestAsync(listenRequest, TestContext.Current.CancellationToken) + .WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); + + var ack = await ackChannel.Reader.ReadAsync(TestContext.Current.CancellationToken); + var subscriptionId = GetSubscriptionId(ack); + Assert.NotNull(subscriptionId); + + var updated = await updatedChannel.Reader.ReadAsync(TestContext.Current.CancellationToken); + Assert.Equal(subscriptionId, GetSubscriptionId(updated)); + Assert.Equal(subscribedUri, Assert.IsType(updated.Params)["uri"]?.GetValue()); + } + + [Fact] + public async Task SubscriptionsListen_WithCustomHandler_InStatelessMode_AdvertisesAndStreamsListChanged() + { + // resources/updated rides on resources.subscribe, which is never suppressed, so it cannot prove the + // listChanged capability is advertised. A custom SubscriptionsListenHandler gives a stateless server a + // way to deliver */list_changed over the held-open POST, so server/discover (the only path a + // 2026-07-28+ client uses) must advertise tools.listChanged rather than dropping it (issue #1662). + Builder.Services.AddMcpServer() + .WithHttpTransport(options => + { + options.Stateless = true; + }) + .WithTools([McpServerTool.Create(() => "result", new() { Name = "myTool" })]) + .WithSubscriptionsListenHandler(async (request, cancellationToken) => + { + var subscriptionId = request.JsonRpcRequest.Id; + + var ack = new JsonRpcNotification + { + Method = NotificationMethods.SubscriptionsAcknowledgedNotification, + Params = JsonSerializer.SerializeToNode( + new SubscriptionsAcknowledgedNotificationParams + { + Notifications = new SubscriptionsListenNotifications + { + ToolsListChanged = request.Params.Notifications.ToolsListChanged, + }, + }, + McpJsonUtilities.DefaultOptions), + }; + TagWithSubscriptionId(ack, subscriptionId); + await request.Server.SendMessageAsync(ack, cancellationToken); + + var listChanged = new JsonRpcNotification { Method = NotificationMethods.ToolListChangedNotification }; + TagWithSubscriptionId(listChanged, subscriptionId); + await request.Server.SendMessageAsync(listChanged, cancellationToken); + + return new EmptyResult(); + }); + + // Advertise tools.listChanged so the per-response capability decision has something to preserve. + Builder.Services.Configure(options => + { + options.Capabilities ??= new(); + options.Capabilities.Tools ??= new(); + options.Capabilities.Tools.ListChanged = true; + }); + + _app = Builder.Build(); + _app.MapMcp(); + await _app.StartAsync(TestContext.Current.CancellationToken); + + HttpClient.DefaultRequestHeaders.Accept.Add(new("application/json")); + HttpClient.DefaultRequestHeaders.Accept.Add(new("text/event-stream")); + + await using var client = await ConnectMcpClientAsync(); + + // The stateless server can now deliver tools/list_changed over the custom listen stream, so the + // capability must survive on the server/discover response instead of being cleared. + Assert.True(client.ServerCapabilities.Tools?.ListChanged); + + var listChangedChannel = Channel.CreateUnbounded(); + await using var listChangedReg = client.RegisterNotificationHandler(NotificationMethods.ToolListChangedNotification, + (notification, _) => { listChangedChannel.Writer.TryWrite(notification); return default; }); + + var listenRequest = new JsonRpcRequest + { + Method = RequestMethods.SubscriptionsListen, + Params = JsonSerializer.SerializeToNode( + new SubscriptionsListenRequestParams + { + Notifications = new SubscriptionsListenNotifications { ToolsListChanged = true }, + }, + McpJsonUtilities.DefaultOptions), + }; + + await client.SendRequestAsync(listenRequest, TestContext.Current.CancellationToken) + .WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); + + var listChangedNotification = await listChangedChannel.Reader.ReadAsync(TestContext.Current.CancellationToken); + Assert.NotNull(GetSubscriptionId(listChangedNotification)); + } + + private static string? GetSubscriptionId(JsonRpcNotification notification) + => ((notification.Params as JsonObject)?["_meta"] as JsonObject)?[MetaKeys.SubscriptionId]?.ToJsonString(); + + private static void TagWithSubscriptionId(JsonRpcNotification notification, RequestId subscriptionId) + { + var paramsObject = notification.Params as JsonObject ?? new JsonObject(); + if (paramsObject["_meta"] is not JsonObject meta) + { + meta = new JsonObject(); + paramsObject["_meta"] = meta; + } + + meta[MetaKeys.SubscriptionId] = subscriptionId.Id switch + { + string stringId => JsonValue.Create(stringId), + long longId => JsonValue.Create(longId), + _ => null, + }; + + notification.Params = paramsObject; + } + [McpServerTool(Name = "testSamplingErrors")] public static async Task TestSamplingErrors(McpServer server) { diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/StreamableHttpClientConformanceTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/StreamableHttpClientConformanceTests.cs index c8e3f8d7b..649286b09 100644 --- a/tests/ModelContextProtocol.AspNetCore.Tests/StreamableHttpClientConformanceTests.cs +++ b/tests/ModelContextProtocol.AspNetCore.Tests/StreamableHttpClientConformanceTests.cs @@ -4,6 +4,7 @@ using Microsoft.Extensions.DependencyInjection; using ModelContextProtocol.AspNetCore.Tests.Utils; using ModelContextProtocol.Client; +using ModelContextProtocol.Extensions.Tasks; using ModelContextProtocol.Protocol; using ModelContextProtocol.Server; using ModelContextProtocol.Tests.Utils; @@ -11,6 +12,7 @@ using System.Threading; using System.Threading.Tasks; using System.Text.Json; +using System.Text.Json.Nodes; using System.Text.Json.Serialization.Metadata; namespace ModelContextProtocol.AspNetCore.Tests; @@ -20,7 +22,7 @@ public class StreamableHttpClientConformanceTests(ITestOutputHelper outputHelper private WebApplication? _app; private readonly List _deleteRequestSessionIds = []; - // Don't add the delete endpoint by default to ensure the client still works with basic sessionless servers. + // Don't add the delete endpoint by default to ensure the client still works with basic stateless servers. private async Task StartAsync(bool enableDelete = false) { Builder.Services.Configure(options => @@ -55,7 +57,7 @@ private async Task StartAsync(bool enableDelete = false) Id = request.Id, Result = JsonSerializer.SerializeToNode(new InitializeResult { - ProtocolVersion = "2024-11-05", + ProtocolVersion = "2025-11-25", Capabilities = new() { Tools = new(), @@ -128,7 +130,7 @@ private async Task StartResumeServerAsync(string expectedSessi } [Fact] - public async Task CanCallToolOnSessionlessStreamableHttpServer() + public async Task CanCallToolOnStatelessStreamableHttpServer() { await StartAsync(); @@ -138,7 +140,7 @@ public async Task CanCallToolOnSessionlessStreamableHttpServer() TransportMode = HttpTransportMode.StreamableHttp, }, HttpClient, LoggerFactory); - await using var client = await McpClient.CreateAsync(transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions { ProtocolVersion = "2025-11-25" }, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); var echoTool = Assert.Single(tools); @@ -158,7 +160,7 @@ public async Task CanCallToolConcurrently() TransportMode = HttpTransportMode.StreamableHttp, }, HttpClient, LoggerFactory); - await using var client = await McpClient.CreateAsync(transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions { ProtocolVersion = "2025-11-25" }, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); var echoTool = Assert.Single(tools); @@ -184,7 +186,7 @@ public async Task SendsDeleteRequestOnDispose() TransportMode = HttpTransportMode.StreamableHttp, }, HttpClient, LoggerFactory); - await using var client = await McpClient.CreateAsync(transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions { ProtocolVersion = "2025-11-25" }, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); // Dispose should trigger DELETE request await client.DisposeAsync(); @@ -206,7 +208,7 @@ public async Task DoesNotSendDeleteWhenTransportDoesNotOwnSession() OwnsSession = false, }, HttpClient, LoggerFactory); - await using (await McpClient.CreateAsync(transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)) + await using (await McpClient.CreateAsync(transport, new McpClientOptions { ProtocolVersion = "2025-11-25" }, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)) { // No-op. Disposing the client should not trigger a DELETE request. } @@ -277,7 +279,7 @@ public async Task CreateAsyncWithKnownSessionIdThrows() }, HttpClient, LoggerFactory); var exception = await Assert.ThrowsAsync(() => - McpClient.CreateAsync(transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)); + McpClient.CreateAsync(transport, new McpClientOptions { ProtocolVersion = "2025-11-25" }, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)); Assert.Contains(nameof(McpClient.ResumeSessionAsync), exception.Message); } @@ -311,7 +313,7 @@ public async Task DisposeAsync_DoesNotHang_WhenOwnsSessionIsFalse_WithActiveGetS Id = request.Id, Result = JsonSerializer.SerializeToNode(new InitializeResult { - ProtocolVersion = "2024-11-05", + ProtocolVersion = "2025-11-25", Capabilities = new() { Tools = new() }, ServerInfo = new Implementation { Name = "hang-test", Version = "0.0.1" }, }, McpJsonUtilities.DefaultOptions) @@ -358,7 +360,7 @@ public async Task DisposeAsync_DoesNotHang_WhenOwnsSessionIsFalse_WithActiveGetS OwnsSession = false, }, HttpClient, LoggerFactory); - await using (var client = await McpClient.CreateAsync(transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)) + await using (var client = await McpClient.CreateAsync(transport, new McpClientOptions { ProtocolVersion = "2025-11-25" }, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)) { var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); Assert.Single(tools); @@ -403,7 +405,7 @@ public async Task Completion_SessionExpiredOnPost_ReturnsHttpCompletionDetails() Id = request.Id, Result = JsonSerializer.SerializeToNode(new InitializeResult { - ProtocolVersion = "2024-11-05", + ProtocolVersion = "2025-11-25", Capabilities = new() { Tools = new() }, ServerInfo = new Implementation { Name = "expiry-test", Version = "0.0.1" }, }, McpJsonUtilities.DefaultOptions) @@ -421,7 +423,7 @@ public async Task Completion_SessionExpiredOnPost_ReturnsHttpCompletionDetails() TransportMode = HttpTransportMode.StreamableHttp, }, HttpClient, LoggerFactory); - var client = await McpClient.CreateAsync(transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + var client = await McpClient.CreateAsync(transport, new McpClientOptions { ProtocolVersion = "2025-11-25" }, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); Assert.Equal("expiry-test-session", client.SessionId); Assert.False(client.Completion.IsCompleted); @@ -464,7 +466,7 @@ public async Task Completion_SessionExpiredOnGet_ReturnsHttpCompletionDetails() Id = request.Id, Result = JsonSerializer.SerializeToNode(new InitializeResult { - ProtocolVersion = "2024-11-05", + ProtocolVersion = "2025-11-25", Capabilities = new() { Tools = new() }, ServerInfo = new Implementation { Name = "get-expiry-test", Version = "0.0.1" }, }, McpJsonUtilities.DefaultOptions) @@ -489,7 +491,7 @@ public async Task Completion_SessionExpiredOnGet_ReturnsHttpCompletionDetails() TransportMode = HttpTransportMode.StreamableHttp, }, HttpClient, LoggerFactory); - var client = await McpClient.CreateAsync(transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + var client = await McpClient.CreateAsync(transport, new McpClientOptions { ProtocolVersion = "2025-11-25" }, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); Assert.Equal("get-expiry-test", client.SessionId); // Trigger session expiry on the GET SSE stream @@ -512,7 +514,7 @@ public async Task Completion_GracefulDisposal_ReturnsCompletionDetails() TransportMode = HttpTransportMode.StreamableHttp, }, HttpClient, LoggerFactory); - var client = await McpClient.CreateAsync(transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + var client = await McpClient.CreateAsync(transport, new McpClientOptions { ProtocolVersion = "2025-11-25" }, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); Assert.False(client.Completion.IsCompleted); await client.DisposeAsync(); @@ -549,6 +551,302 @@ private static string Echo(string message) return message; } + #region SEP-2243 Client Header Tests + + [Fact] + public async Task ListTools_FiltersToolsWithInvalidHeaderAnnotations() + { + // Start a mock server that returns tools with both valid and invalid x-mcp-header annotations + await StartHeaderToolServer(); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new("http://localhost:5000/mcp"), + TransportMode = HttpTransportMode.StreamableHttp, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions { ProtocolVersion = "2025-11-25" }, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + // The server returns 3 tools: valid_tool, invalid_space_tool, invalid_duplicate_tool + // The client should filter out tools with invalid x-mcp-header annotations + var toolNames = tools.Select(t => t.Name).ToList(); + Assert.Contains("valid_tool", toolNames); + Assert.DoesNotContain("invalid_space_tool", toolNames); + Assert.DoesNotContain("invalid_duplicate_tool", toolNames); + } + + [Fact] + public async Task Client_SendsCorrectHeaders_EndToEnd() + { + // Start a server that captures request headers for verification + var capturedHeaders = new Dictionary(StringComparer.OrdinalIgnoreCase); + await StartHeaderCapturingServer(capturedHeaders); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new("http://localhost:5000/mcp"), + TransportMode = HttpTransportMode.StreamableHttp, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions { ProtocolVersion = "2025-11-25" }, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + var tool = Assert.Single(tools); + Assert.Equal("header_tool", tool.Name); + + // Call the tool — client should send Mcp-Param-* headers automatically + capturedHeaders.Clear(); + await tool.CallAsync(new Dictionary { ["region"] = "us-west-2" }, cancellationToken: TestContext.Current.CancellationToken); + + // Verify the client sent the correct headers + Assert.True(capturedHeaders.ContainsKey("Mcp-Method"), "Expected Mcp-Method header"); + Assert.Equal("tools/call", capturedHeaders["Mcp-Method"]); + Assert.True(capturedHeaders.ContainsKey("Mcp-Name"), "Expected Mcp-Name header"); + Assert.Equal("header_tool", capturedHeaders["Mcp-Name"]); + Assert.True(capturedHeaders.ContainsKey("Mcp-Param-Region"), "Expected Mcp-Param-Region header"); + Assert.Equal("us-west-2", capturedHeaders["Mcp-Param-Region"]); + } + + [Fact] + public async Task TasksClient_SendsRoutingNameHeader_EndToEnd() + { + var capturedHeaders = new Dictionary(StringComparer.OrdinalIgnoreCase); + await StartHeaderCapturingServer(capturedHeaders, supportsTasks: true); + + await using var transport = new HttpClientTransport(new() + { + Endpoint = new("http://localhost:5000/mcp"), + TransportMode = HttpTransportMode.StreamableHttp, + }, HttpClient, LoggerFactory); + + await using var client = await McpClient.CreateAsync( + transport, + new McpClientOptions { ProtocolVersion = "2026-07-28" }, + loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken); + + capturedHeaders.Clear(); + await client.GetTaskAsync("task-42", TestContext.Current.CancellationToken); + + Assert.Equal("tasks/get", capturedHeaders[McpHttpHeaders.Method]); + Assert.Equal("task-42", capturedHeaders[McpHttpHeaders.Name]); + } + + private async Task StartHeaderToolServer() + { + Builder.Services.Configure(options => + { + options.SerializerOptions.TypeInfoResolverChain.Add(McpJsonUtilities.DefaultOptions.TypeInfoResolver!); + }); + _app = Builder.Build(); + + _app.MapPost("/mcp", (JsonRpcMessage message) => + { + if (message is not JsonRpcRequest request) + { + return Results.Accepted(); + } + + if (request.Method == "initialize") + { + return Results.Json(new JsonRpcResponse + { + Id = request.Id, + Result = JsonSerializer.SerializeToNode(new InitializeResult + { + ProtocolVersion = "2025-11-25", + Capabilities = new() { Tools = new() }, + ServerInfo = new Implementation { Name = "header-test-server", Version = "1.0" }, + }, McpJsonUtilities.DefaultOptions) + }); + } + + if (request.Method == "tools/list") + { + // Return tools with various x-mcp-header annotations — some valid, some invalid + var toolsJson = JsonSerializer.SerializeToNode(new ListToolsResult + { + Tools = + [ + CreateToolWithSchema("valid_tool", """ + { + "type": "object", + "properties": { + "region": { "type": "string", "x-mcp-header": "Region" } + } + } + """), + CreateToolWithSchema("invalid_space_tool", """ + { + "type": "object", + "properties": { + "value": { "type": "string", "x-mcp-header": "Invalid Name" } + } + } + """), + CreateToolWithSchema("invalid_duplicate_tool", """ + { + "type": "object", + "properties": { + "a": { "type": "string", "x-mcp-header": "Same" }, + "b": { "type": "string", "x-mcp-header": "Same" } + } + } + """), + ] + }, McpJsonUtilities.DefaultOptions); + + return Results.Json(new JsonRpcResponse + { + Id = request.Id, + Result = toolsJson, + }); + } + + return Results.Accepted(); + }); + + await _app.StartAsync(TestContext.Current.CancellationToken); + } + + private async Task StartHeaderCapturingServer( + Dictionary capturedHeaders, + bool supportsTasks = false) + { + Builder.Services.Configure(options => + { + options.SerializerOptions.TypeInfoResolverChain.Add(McpJsonUtilities.DefaultOptions.TypeInfoResolver!); + }); + _app = Builder.Build(); + + _app.MapPost("/mcp", (JsonRpcMessage message, HttpContext context) => + { + if (message is not JsonRpcRequest request) + { + return Results.Accepted(); + } + + if (request.Method == "initialize") + { + return Results.Json(new JsonRpcResponse + { + Id = request.Id, + Result = JsonSerializer.SerializeToNode(new InitializeResult + { + ProtocolVersion = "2025-11-25", + Capabilities = new() + { + Tools = new(), + Extensions = supportsTasks + ? new Dictionary + { + ["io.modelcontextprotocol/tasks"] = new JsonObject(), + } + : null, + }, + ServerInfo = new Implementation { Name = "header-capture", Version = "1.0" }, + }, McpJsonUtilities.DefaultOptions) + }); + } + + if (request.Method == "server/discover" && supportsTasks) + { + return Results.Json(new JsonRpcResponse + { + Id = request.Id, + Result = JsonSerializer.SerializeToNode(new DiscoverResult + { + SupportedVersions = ["2026-07-28"], + Capabilities = new() + { + Tools = new(), + Extensions = new Dictionary + { + ["io.modelcontextprotocol/tasks"] = new JsonObject(), + }, + }, + Meta = new JsonObject + { + [MetaKeys.ServerInfo] = JsonSerializer.SerializeToNode(new Implementation { Name = "header-capture", Version = "1.0" }, McpJsonUtilities.DefaultOptions), + }, + TimeToLive = TimeSpan.Zero, + CacheScope = CacheScope.Private, + ResultType = "complete", + }, McpJsonUtilities.DefaultOptions), + }); + } + + if (request.Method == "tools/list") + { + return Results.Json(new JsonRpcResponse + { + Id = request.Id, + Result = JsonSerializer.SerializeToNode(new ListToolsResult + { + Tools = [CreateToolWithSchema("header_tool", """ + { + "type": "object", + "properties": { + "region": { "type": "string", "x-mcp-header": "Region" } + }, + "required": ["region"] + } + """)] + }, McpJsonUtilities.DefaultOptions), + }); + } + + if (request.Method is "tools/call" or "tasks/get") + { + // Capture all MCP headers for verification + foreach (var header in context.Request.Headers) + { + if (header.Key.StartsWith("Mcp-", StringComparison.OrdinalIgnoreCase)) + { + capturedHeaders[header.Key] = header.Value.ToString(); + } + } + + if (request.Method == "tasks/get") + { + return Results.Json(new JsonRpcResponse + { + Id = request.Id, + Result = JsonNode.Parse( + """{"taskId":"task-42","status":"working","createdAt":"2026-01-01T00:00:00Z","lastUpdatedAt":"2026-01-01T00:00:00Z"}"""), + }); + } + + var parameters = JsonSerializer.Deserialize(request.Params, GetJsonTypeInfo()); + return Results.Json(new JsonRpcResponse + { + Id = request.Id, + Result = JsonSerializer.SerializeToNode(new CallToolResult + { + Content = [new TextContentBlock { Text = "ok" }], + }, McpJsonUtilities.DefaultOptions), + }); + } + + return Results.Accepted(); + }); + + await _app.StartAsync(TestContext.Current.CancellationToken); + } + + private static Tool CreateToolWithSchema(string name, string schemaJson) + { + using var doc = JsonDocument.Parse(schemaJson); + return new Tool + { + Name = name, + InputSchema = doc.RootElement.Clone(), + }; + } + + #endregion + private sealed class ResumeTestServer { private static readonly Tool ResumeTool = new() diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/StreamableHttpServerConformanceTests.cs b/tests/ModelContextProtocol.AspNetCore.Tests/StreamableHttpServerConformanceTests.cs index bbe642ab6..dd051e4d3 100644 --- a/tests/ModelContextProtocol.AspNetCore.Tests/StreamableHttpServerConformanceTests.cs +++ b/tests/ModelContextProtocol.AspNetCore.Tests/StreamableHttpServerConformanceTests.cs @@ -1,4 +1,4 @@ -using Microsoft.AspNetCore.Builder; +using Microsoft.AspNetCore.Builder; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Logging; using Microsoft.Extensions.Time.Testing; @@ -27,7 +27,7 @@ public class StreamableHttpServerConformanceTests(ITestOutputHelper outputHelper private WebApplication? _app; - private async Task StartAsync() + private async Task StartAsync(bool stateless = false) { Builder.Services.AddMcpServer(options => { @@ -36,7 +36,7 @@ private async Task StartAsync() Name = nameof(StreamableHttpServerConformanceTests), Version = "73", }; - }).WithTools(Tools).WithHttpTransport(); + }).WithTools(Tools).WithHttpTransport(options => options.Stateless = stateless); _app = Builder.Build(); @@ -65,7 +65,7 @@ public async Task NegativeNonInfiniteIdleTimeout_Throws_ArgumentOutOfRangeExcept options.IdleTimeout = TimeSpan.MinValue; }); - var ex = await Assert.ThrowsAnyAsync(StartAsync); + var ex = await Assert.ThrowsAnyAsync(() => StartAsync()); Assert.Contains("IdleTimeout", ex.Message); } @@ -77,7 +77,7 @@ public async Task NegativeMaxIdleSessionCount_Throws_ArgumentOutOfRangeException options.MaxIdleSessionCount = -1; }); - var ex = await Assert.ThrowsAnyAsync(StartAsync); + var ex = await Assert.ThrowsAnyAsync(() => StartAsync()); Assert.Contains("MaxIdleSessionCount", ex.Message); } @@ -204,6 +204,31 @@ public async Task PostRequest_Succeeds_WithValidProtocolVersionHeader() Assert.Equal(HttpStatusCode.OK, response.StatusCode); } + [Theory] + [InlineData(false, McpProtocolVersions.March2025ProtocolVersion, McpProtocolVersions.November2025ProtocolVersion)] + [InlineData(false, McpProtocolVersions.November2025ProtocolVersion, McpProtocolVersions.March2025ProtocolVersion)] + [InlineData(true, McpProtocolVersions.March2025ProtocolVersion, McpProtocolVersions.November2025ProtocolVersion)] + [InlineData(true, McpProtocolVersions.November2025ProtocolVersion, McpProtocolVersions.March2025ProtocolVersion)] + public async Task InitializeRequest_IsBadRequest_WhenProtocolVersionHeaderDoesNotMatchBody( + bool stateless, + string protocolVersionHeader, + string protocolVersionBody) + { + await StartAsync(stateless); + + var body = $$$$""" + {"jsonrpc":"2.0","id":4242,"method":"initialize","params":{"protocolVersion":"{{{{protocolVersionBody}}}}","capabilities":{},"clientInfo":{"name":"IntegrationTestClient","version":"1.0.0"}}} + """; + using var request = new HttpRequestMessage(HttpMethod.Post, "") { Content = JsonContent(body) }; + request.Headers.Add("MCP-Protocol-Version", protocolVersionHeader); + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + var json = JsonNode.Parse(await response.Content.ReadAsStringAsync(TestContext.Current.CancellationToken)); + Assert.Equal(4242, json!["id"]!.GetValue()); + Assert.Equal((int)McpErrorCode.HeaderMismatch, json["error"]!["code"]!.GetValue()); + } + [Fact] public async Task GetRequest_IsBadRequest_WithInvalidProtocolVersionHeader() { @@ -224,7 +249,7 @@ public async Task PostRequest_IsNotFound_WithUnrecognizedSessionId() using var request = new HttpRequestMessage(HttpMethod.Post, "") { - Content = JsonContent(EchoRequest), + Content = JsonContent("""{"jsonrpc":"2.0","id":4242,"method":"tools/call","params":{"name":"echo","arguments":{"message":"hi"}}}"""), Headers = { { "mcp-session-id", "fakeSession" }, @@ -232,6 +257,11 @@ public async Task PostRequest_IsNotFound_WithUnrecognizedSessionId() }; using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); Assert.Equal(HttpStatusCode.NotFound, response.StatusCode); + + // The request body parsed successfully, so the JSON-RPC error MUST echo its id rather than + // emitting id=null (base protocol responses section; see #1677). + using var doc = JsonDocument.Parse(await response.Content.ReadAsStringAsync(TestContext.Current.CancellationToken)); + Assert.Equal(4242, doc.RootElement.GetProperty("id").GetInt64()); } [Fact] @@ -245,6 +275,63 @@ public async Task PostWithoutSessionId_NonInitializeRequest_Returns400() var body = await response.Content.ReadAsStringAsync(TestContext.Current.CancellationToken); Assert.Contains("Mcp-Session-Id", body); Assert.Contains("Stateless", body); + + // The request body parsed successfully, so the JSON-RPC error MUST echo its id (see #1677). + using var doc = JsonDocument.Parse(body); + Assert.Equal(1, doc.RootElement.GetProperty("id").GetInt64()); + } + + [Fact] + public async Task StatelessPostWithSessionId_Returns400_EchoesRequestId() + { + await StartAsync(stateless: true); + + using var request = new HttpRequestMessage(HttpMethod.Post, "") + { + Content = JsonContent("""{"jsonrpc":"2.0","id":4242,"method":"tools/list","params":{}}"""), + Headers = + { + { "mcp-session-id", "someSession" }, + }, + }; + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + + // The request body parsed successfully, so the stateless-mode rejection MUST echo its id (see #1677). + using var doc = JsonDocument.Parse(await response.Content.ReadAsStringAsync(TestContext.Current.CancellationToken)); + Assert.Equal(4242, doc.RootElement.GetProperty("id").GetInt64()); + } + + [Fact] + public async Task PostMalformedJson_Returns400_InvalidRequest_WithNullId() + { + await StartAsync(); + + using var response = await HttpClient.PostAsync("", JsonContent("{ this is not valid json"), TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + + // The server must emit a conformant JSON-RPC error envelope (not a raw 500). Because the request + // id could not be read, the error carries id=null per JSON-RPC 2.0 §5.1 — and crucially it must + // serialize as JSON null, not "" (regression guard for the RequestId write path). + using var doc = JsonDocument.Parse(await response.Content.ReadAsStringAsync(TestContext.Current.CancellationToken)); + Assert.Equal(JsonValueKind.Null, doc.RootElement.GetProperty("id").ValueKind); + Assert.Equal((int)McpErrorCode.InvalidRequest, doc.RootElement.GetProperty("error").GetProperty("code").GetInt32()); + } + + [Fact] + public async Task PostRequestWithExplicitNullId_Returns400_InvalidRequest_WithNullId() + { + await StartAsync(); + + // A request carrying an explicit `id:null` is malformed per the MCP base protocol ("the ID MUST + // NOT be null") and must NOT be silently treated as a notification. The server rejects it with a + // conformant 400 InvalidRequest error whose own id is null. + using var response = await HttpClient.PostAsync("", JsonContent("""{"jsonrpc":"2.0","id":null,"method":"tools/list"}"""), TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + + using var doc = JsonDocument.Parse(await response.Content.ReadAsStringAsync(TestContext.Current.CancellationToken)); + Assert.Equal(JsonValueKind.Null, doc.RootElement.GetProperty("id").ValueKind); + Assert.Equal((int)McpErrorCode.InvalidRequest, doc.RootElement.GetProperty("error").GetProperty("code").GetInt32()); } [Fact] @@ -384,7 +471,8 @@ async Task GetFirstNotificationAsync() public async Task SendNotificationAsync_DoesNotThrow_WhenNoGetRequestHasBeenMade() { // Clients are not required to make a GET request for unsolicited messages. - // If no GET request has been made, the messages should be dropped rather than throwing. + // If no GET request has been made, the messages should be dropped rather than throwing, + // and the drop should be visible as a Debug-level log so it can be diagnosed. McpServer? server = null; Builder.Services.AddMcpServer() @@ -409,6 +497,156 @@ public async Task SendNotificationAsync_DoesNotThrow_WhenNoGetRequestHasBeenMade var exception = await Record.ExceptionAsync(() => server.SendNotificationAsync("test-method", TestContext.Current.CancellationToken)); Assert.Null(exception); + + Assert.Contains(MockLoggerProvider.LogMessages, log => + log.Category == typeof(StreamableHttpServerTransport).FullName && + log.LogLevel == LogLevel.Debug && + log.Message.Contains("test-method") && + log.Message.Contains("no GET SSE stream")); + } + + [Fact] + public async Task SendRequestAsync_Throws_WhenNoGetRequestHasBeenMade() + { + // A server-to-client request sent before any GET SSE stream is opened can never + // receive a response, so the transport should fail fast with InvalidOperationException + // instead of silently dropping the message and leaving the caller hanging on the TCS + // registered by SendRequestAsync. + McpServer? server = null; + + Builder.Services.AddMcpServer() + .WithHttpTransport(options => + { +#pragma warning disable MCPEXP002 // RunSessionHandler is experimental + options.RunSessionHandler = (httpContext, mcpServer, cancellationToken) => + { + server = mcpServer; + return mcpServer.RunAsync(cancellationToken); + }; +#pragma warning restore MCPEXP002 + }); + + await StartAsync(); + + await CallInitializeAndValidateAsync(); + Assert.NotNull(server); + + var request = new JsonRpcRequest + { + Method = "roots/list", + Id = new RequestId(42), + }; + + var ex = await Assert.ThrowsAsync(() => + server.SendRequestAsync(request, TestContext.Current.CancellationToken)); + + Assert.Contains("roots/list", ex.Message); + Assert.Contains("no GET SSE stream", ex.Message); + Assert.Contains("RequestContext", ex.Message); + Assert.Contains("RelatedTransport", ex.Message); + } + + [Fact] + public async Task SendMessageAsync_LogsWarning_OnUnexpectedResponse_WhenNoGetRequestHasBeenMade() + { + // Responses normally ride the originating POST response stream via RelatedTransport, so + // receiving one through the GET path without an open GET is unexpected. The message is + // dropped (preserving best-effort semantics) but a warning is logged so the situation is + // visible. + McpServer? server = null; + + Builder.Services.AddMcpServer() + .WithHttpTransport(options => + { +#pragma warning disable MCPEXP002 // RunSessionHandler is experimental + options.RunSessionHandler = (httpContext, mcpServer, cancellationToken) => + { + server = mcpServer; + return mcpServer.RunAsync(cancellationToken); + }; +#pragma warning restore MCPEXP002 + }); + + await StartAsync(); + + await CallInitializeAndValidateAsync(); + Assert.NotNull(server); + + var response = new JsonRpcResponse + { + Id = new RequestId(7), + Result = new JsonObject(), + }; + + var exception = await Record.ExceptionAsync(() => + server.SendMessageAsync(response, TestContext.Current.CancellationToken)); + Assert.Null(exception); + + Assert.Contains(MockLoggerProvider.LogMessages, log => + log.Category == typeof(StreamableHttpServerTransport).FullName && + log.LogLevel == LogLevel.Warning && + log.Message.Contains(nameof(JsonRpcResponse)) && + log.Message.Contains("no GET SSE stream")); + } + + [Fact] + public async Task SendRequestAsync_LogsWarning_WhenGetRequestIsOpen() + { + // Even when the GET SSE stream is open and the request is delivered, server-to-client + // requests sent via the GET path are fragile (no per-request correlation, depend on a + // long-lived GET, race with startup/teardown). A warning is logged to direct callers at + // the RequestContext.RelatedTransport channel instead, without changing behavior. + McpServer? server = null; + + Builder.Services.AddMcpServer() + .WithHttpTransport(options => + { +#pragma warning disable MCPEXP002 // RunSessionHandler is experimental + options.RunSessionHandler = (httpContext, mcpServer, cancellationToken) => + { + server = mcpServer; + return mcpServer.RunAsync(cancellationToken); + }; +#pragma warning restore MCPEXP002 + }); + + await StartAsync(); + + await CallInitializeAndValidateAsync(); + Assert.NotNull(server); + + using var getResponse = await HttpClient.GetAsync("", HttpCompletionOption.ResponseHeadersRead, TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.OK, getResponse.StatusCode); + + // Send a request via the GET stream and assert it lands on the wire (proving behavior is unchanged). + // SendRequestAsync awaits a response that the test never produces, so use a CTS to cancel after + // confirming wire delivery. + var request = new JsonRpcRequest + { + Method = "roots/list", + Id = new RequestId(99), + }; + + using var requestCts = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken); + var sendTask = server.SendRequestAsync(request, requestCts.Token); + + await foreach (var sseEvent in ReadSseAsync(getResponse.Content)) + { + var received = JsonSerializer.Deserialize(sseEvent, GetJsonTypeInfo()); + Assert.NotNull(received); + Assert.Equal("roots/list", received.Method); + break; + } + + // Cancel the awaited response so SendRequestAsync completes — the wire delivery has already happened. + requestCts.Cancel(); + await Assert.ThrowsAnyAsync(() => sendTask); + + Assert.Contains(MockLoggerProvider.LogMessages, log => + log.Category == typeof(StreamableHttpServerTransport).FullName && + log.LogLevel == LogLevel.Warning && + log.Message.Contains("roots/list") && + log.Message.Contains("RequestContext")); } [Fact] @@ -730,6 +968,99 @@ public async Task McpServer_UsedOutOfScope_CanSendNotifications() Assert.Equal(NotificationMethods.ResourceUpdatedNotification, notification.Method); } + #region SEP-2243 Header Validation Tests + + [Fact] + public async Task July2026ProtocolVersion_RejectsMissingMcpMethodHeader() + { + // Starting with the 2026-07-28 protocol revision, Streamable HTTP no longer supports sessions (SEP-2567) and is served only on a stateless server. + await StartAsync(stateless: true); + + // Probe with the 2026-07-28 protocol version to enable header validation. + await CallDiscoverWithJuly2026ProtocolVersionAndValidateAsync(); + + // Send a tools/call request without Mcp-Method header — should be rejected + using var request = new HttpRequestMessage(HttpMethod.Post, ""); + request.Content = JsonContent(CallTool("echo", """{"message":"test"}""", includePerRequestMetadata: true)); + request.Headers.Add("MCP-Protocol-Version", "2026-07-28"); + // Deliberately omit Mcp-Method header + + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + } + + [Fact] + public async Task July2026ProtocolVersion_RejectsMismatchedMcpMethodHeader() + { + await StartAsync(stateless: true); + await CallDiscoverWithJuly2026ProtocolVersionAndValidateAsync(); + + // Send a tools/call request but set Mcp-Method to wrong value + using var request = new HttpRequestMessage(HttpMethod.Post, ""); + request.Content = JsonContent(CallTool("echo", """{"message":"test"}""", includePerRequestMetadata: true)); + request.Headers.Add("MCP-Protocol-Version", "2026-07-28"); + request.Headers.Add("Mcp-Method", "resources/read"); // Wrong method + + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); + } + + [Fact] + public async Task July2026ProtocolVersion_AcceptsCorrectMcpMethodHeader() + { + await StartAsync(stateless: true); + await CallDiscoverWithJuly2026ProtocolVersionAndValidateAsync(); + + // Send a tools/call request with correct Mcp-Method and Mcp-Name headers + using var request = new HttpRequestMessage(HttpMethod.Post, ""); + request.Content = JsonContent(CallTool("echo", """{"message":"hello"}""", includePerRequestMetadata: true)); + request.Headers.Add("MCP-Protocol-Version", "2026-07-28"); + request.Headers.Add("Mcp-Method", "tools/call"); + request.Headers.Add("Mcp-Name", "echo"); + + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + } + + [Fact] + public async Task InitializeHandshakeVersion_DoesNotRequireMcpMethodHeader() + { + await StartAsync(); + await CallInitializeAndValidateAsync(); + + // With the initialize-handshake version, Mcp-Method header is not required. + using var request = new HttpRequestMessage(HttpMethod.Post, ""); + request.Content = JsonContent(CallTool("echo", """{"message":"hello"}""")); + request.Headers.Add("MCP-Protocol-Version", "2025-03-26"); + // No Mcp-Method header — should still work + + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + } + + private async Task CallDiscoverWithJuly2026ProtocolVersionAndValidateAsync() + { + HttpClient.DefaultRequestHeaders.Remove("mcp-session-id"); + + using var request = new HttpRequestMessage(HttpMethod.Post, ""); + request.Content = JsonContent(DiscoverRequestJuly2026Protocol); + request.Headers.Add("MCP-Protocol-Version", "2026-07-28"); + request.Headers.Add("Mcp-Method", "server/discover"); + + using var response = await HttpClient.SendAsync(request, TestContext.Current.CancellationToken); + var rpcResponse = await AssertSingleSseResponseAsync(response); + AssertDiscoverServerInfo(rpcResponse); + + // Starting with the 2026-07-28 protocol revision, clients use server/discover and per-request + // metadata instead of initialize. + } + + private static string DiscoverRequestJuly2026Protocol => """ + {"jsonrpc":"2.0","id":1,"method":"server/discover","params":{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"IntegrationTestClient","version":"1.0.0"},"io.modelcontextprotocol/clientCapabilities":{}}}} + """; + + #endregion + private static StringContent JsonContent(string json) => new(json, Encoding.UTF8, "application/json"); private static JsonTypeInfo GetJsonTypeInfo() => (JsonTypeInfo)McpJsonUtilities.DefaultOptions.GetTypeInfo(typeof(T)); @@ -797,10 +1128,14 @@ private string Request(string method, string parameters = "{}") """; } - private string CallTool(string toolName, string arguments = "{}") => - Request("tools/call", $$""" - {"name":"{{toolName}}","arguments":{{arguments}}} - """); + private string CallTool(string toolName, string arguments = "{}", bool includePerRequestMetadata = false) + { + var meta = includePerRequestMetadata + ? @",""_meta"":{""io.modelcontextprotocol/protocolVersion"":""2026-07-28"",""io.modelcontextprotocol/clientInfo"":{""name"":""IntegrationTestClient"",""version"":""1.0.0""},""io.modelcontextprotocol/clientCapabilities"":{}}" + : ""; + + return Request("tools/call", "{\"name\":\"" + toolName + "\",\"arguments\":" + arguments + meta + "}"); + } private string CallToolWithProgressToken(string toolName, string arguments = "{}") => Request("tools/call", $$$""" @@ -820,6 +1155,20 @@ private static InitializeResult AssertServerInfo(JsonRpcResponse rpcResponse) return initializeResult; } + private static DiscoverResult AssertDiscoverServerInfo(JsonRpcResponse rpcResponse) + { + var discoverResult = AssertType(rpcResponse.Result); + + // Server identity is carried in the result _meta, not the discover body. + var serverInfoNode = discoverResult.Meta?[MetaKeys.ServerInfo]; + Assert.NotNull(serverInfoNode); + var serverInfo = JsonSerializer.Deserialize(serverInfoNode, McpJsonUtilities.DefaultOptions); + Assert.NotNull(serverInfo); + Assert.Equal(nameof(StreamableHttpServerConformanceTests), serverInfo.Name); + Assert.Equal("73", serverInfo.Version); + return discoverResult; + } + private static CallToolResult AssertEchoResponse(JsonRpcResponse rpcResponse) { var callToolResponse = AssertType(rpcResponse.Result); diff --git a/tests/ModelContextProtocol.AspNetCore.Tests/Utils/KestrelInMemoryConnection.cs b/tests/ModelContextProtocol.AspNetCore.Tests/Utils/KestrelInMemoryConnection.cs index c632630b0..59cce6b38 100644 --- a/tests/ModelContextProtocol.AspNetCore.Tests/Utils/KestrelInMemoryConnection.cs +++ b/tests/ModelContextProtocol.AspNetCore.Tests/Utils/KestrelInMemoryConnection.cs @@ -92,7 +92,7 @@ public override Task FlushAsync(CancellationToken cancellationToken) protected override void Dispose(bool disposing) { - // Signal to the server the the client has closed the connection, and dispose the client-half of the Pipes. + // Signal to the server the client has closed the connection, and dispose the client-half of the Pipes. ThreadPool.UnsafeQueueUserWorkItem(static cts => ((CancellationTokenSource)cts!).Cancel(), connectionClosedCts); duplexPipe.Input.Complete(); duplexPipe.Output.Complete(); diff --git a/tests/ModelContextProtocol.ConformanceClient/ConformanceOAuthHelpers.cs b/tests/ModelContextProtocol.ConformanceClient/ConformanceOAuthHelpers.cs new file mode 100644 index 000000000..d9c148d3d --- /dev/null +++ b/tests/ModelContextProtocol.ConformanceClient/ConformanceOAuthHelpers.cs @@ -0,0 +1,298 @@ +using System.Net.Http.Headers; +using System.Security.Cryptography; +using System.Text; +using System.Text.Json; +using Microsoft.Extensions.Logging; +using ModelContextProtocol.Authentication; + +internal sealed class ConformanceContext +{ + private readonly JsonElement _root; + + private ConformanceContext(JsonElement root) + { + _root = root; + } + + public static ConformanceContext? Parse(string? json) + { + if (string.IsNullOrWhiteSpace(json)) + { + return null; + } + + using var document = JsonDocument.Parse(json); + return new ConformanceContext(document.RootElement.Clone()); + } + + public string GetRequiredString(string propertyName) + { + if (!_root.TryGetProperty(propertyName, out var value) || + value.ValueKind != JsonValueKind.String || + string.IsNullOrEmpty(value.GetString())) + { + throw new InvalidOperationException( + $"MCP_CONFORMANCE_CONTEXT is missing required string property '{propertyName}'."); + } + + return value.GetString()!; + } + + public string? GetString(string propertyName) => + _root.TryGetProperty(propertyName, out var value) && value.ValueKind == JsonValueKind.String + ? value.GetString() + : null; +} + +internal static class ConformanceOAuthHelpers +{ + private const string ClientAssertionType = "urn:ietf:params:oauth:client-assertion-type:jwt-bearer"; + + public static async Task AcquireClientCredentialsTokenAsync( + Uri resourceUri, + ConformanceContext context, + bool usePrivateKeyJwt, + CancellationToken cancellationToken) + { + using var httpClient = new HttpClient(); + var discovery = await DiscoverAsync(httpClient, resourceUri, cancellationToken).ConfigureAwait(false); + var clientId = context.GetRequiredString("client_id"); + + Dictionary formFields = new() + { + ["grant_type"] = "client_credentials", + ["resource"] = discovery.Resource, + }; + + if (discovery.Scopes.Count > 0) + { + formFields["scope"] = string.Join(" ", discovery.Scopes); + } + + using var request = new HttpRequestMessage(HttpMethod.Post, discovery.TokenEndpoint); + if (usePrivateKeyJwt) + { + var algorithm = context.GetString("signing_algorithm") ?? "ES256"; + if (!string.Equals(algorithm, "ES256", StringComparison.Ordinal)) + { + throw new InvalidOperationException($"Unsupported client assertion signing algorithm '{algorithm}'."); + } + + formFields["client_assertion_type"] = ClientAssertionType; + formFields["client_assertion"] = CreateEs256ClientAssertion( + clientId, + discovery.AuthorizationServer, + context.GetRequiredString("private_key_pem")); + } + else + { + var credentials = $"{Uri.EscapeDataString(clientId)}:{Uri.EscapeDataString(context.GetRequiredString("client_secret"))}"; + request.Headers.Authorization = new AuthenticationHeaderValue( + "Basic", + Convert.ToBase64String(Encoding.UTF8.GetBytes(credentials))); + } + + request.Content = new FormUrlEncodedContent(formFields); + using var response = await httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false); + return await ReadAccessTokenAsync(response, cancellationToken).ConfigureAwait(false); + } + + public static async Task AcquireEnterpriseTokenAsync( + Uri resourceUri, + ConformanceContext context, + ILoggerFactory loggerFactory, + CancellationToken cancellationToken) + { + using var httpClient = new HttpClient(); + var discovery = await DiscoverAsync(httpClient, resourceUri, cancellationToken).ConfigureAwait(false); + var provider = new IdentityAssertionGrantProvider( + new IdentityAssertionGrantProviderOptions + { + ClientId = context.GetRequiredString("client_id"), + ClientSecret = context.GetRequiredString("client_secret"), + TokenEndpointAuthMethod = "client_secret_basic", + IdpClientId = context.GetRequiredString("idp_client_id"), + IdpTokenEndpoint = context.GetRequiredString("idp_token_endpoint"), + IdTokenCallback = (_, _) => Task.FromResult(context.GetRequiredString("idp_id_token")), + }, + httpClient, + loggerFactory); + + var tokens = await provider.GetAccessTokenAsync( + resourceUri, + new Uri(discovery.AuthorizationServer), + cancellationToken).ConfigureAwait(false); + return tokens.AccessToken; + } + + public static HttpClient CreateBearerHttpClient(string accessToken) + { + var httpClient = new HttpClient(); + httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken); + return httpClient; + } + + private static async Task DiscoverAsync( + HttpClient httpClient, + Uri resourceUri, + CancellationToken cancellationToken) + { + JsonElement? protectedResourceMetadata = null; + foreach (var metadataUri in GetProtectedResourceMetadataUris(resourceUri)) + { + using var response = await httpClient.GetAsync(metadataUri, cancellationToken).ConfigureAwait(false); + if (!response.IsSuccessStatusCode) + { + continue; + } + + protectedResourceMetadata = await ReadJsonAsync(response, cancellationToken).ConfigureAwait(false); + break; + } + + if (protectedResourceMetadata is not { } prm || + !prm.TryGetProperty("authorization_servers", out var authorizationServers) || + authorizationServers.ValueKind != JsonValueKind.Array || + authorizationServers.GetArrayLength() == 0) + { + throw new InvalidOperationException($"No authorization server was discovered for MCP resource '{resourceUri}'."); + } + + var authorizationServer = authorizationServers[0].GetString() + ?? throw new InvalidOperationException("The discovered authorization server URI was null."); + var resource = prm.TryGetProperty("resource", out var resourceProperty) + ? resourceProperty.GetString() ?? resourceUri.ToString() + : resourceUri.ToString(); + List scopes = []; + if (prm.TryGetProperty("scopes_supported", out var scopesProperty) && + scopesProperty.ValueKind == JsonValueKind.Array) + { + foreach (var scope in scopesProperty.EnumerateArray()) + { + if (scope.GetString() is { Length: > 0 } value) + { + scopes.Add(value); + } + } + } + + var authorizationServerUri = new Uri(authorizationServer); + foreach (var metadataUri in GetAuthorizationServerMetadataUris(authorizationServerUri)) + { + using var response = await httpClient.GetAsync(metadataUri, cancellationToken).ConfigureAwait(false); + if (!response.IsSuccessStatusCode) + { + continue; + } + + var metadata = await ReadJsonAsync(response, cancellationToken).ConfigureAwait(false); + if (metadata.TryGetProperty("token_endpoint", out var tokenEndpointProperty) && + tokenEndpointProperty.GetString() is { Length: > 0 } tokenEndpoint) + { + var issuer = metadata.TryGetProperty("issuer", out var issuerProperty) + ? issuerProperty.GetString() ?? authorizationServer + : authorizationServer; + return new OAuthDiscovery(resource, issuer, new Uri(tokenEndpoint), scopes); + } + } + + throw new InvalidOperationException( + $"No authorization server metadata with a token endpoint was discovered for '{authorizationServer}'."); + } + + private static IEnumerable GetProtectedResourceMetadataUris(Uri resourceUri) + { + var authority = resourceUri.GetLeftPart(UriPartial.Authority); + var path = resourceUri.AbsolutePath.Trim('/'); + if (path.Length > 0) + { + yield return new Uri($"{authority}/.well-known/oauth-protected-resource/{path}"); + } + yield return new Uri($"{authority}/.well-known/oauth-protected-resource"); + } + + private static IEnumerable GetAuthorizationServerMetadataUris(Uri authorizationServer) + { + var authority = authorizationServer.GetLeftPart(UriPartial.Authority); + var path = authorizationServer.AbsolutePath.Trim('/'); + if (path.Length == 0) + { + yield return new Uri($"{authority}/.well-known/oauth-authorization-server"); + yield return new Uri($"{authority}/.well-known/openid-configuration"); + } + else + { + yield return new Uri($"{authority}/.well-known/oauth-authorization-server/{path}"); + yield return new Uri($"{authority}/.well-known/openid-configuration/{path}"); + yield return new Uri($"{authority}/{path}/.well-known/openid-configuration"); + } + } + + private static string CreateEs256ClientAssertion(string clientId, string audience, string privateKeyPem) + { + var header = Base64UrlEncode(Encoding.UTF8.GetBytes("""{"alg":"ES256","typ":"JWT"}""")); + var now = DateTimeOffset.UtcNow.ToUnixTimeSeconds(); + + using var payloadStream = new MemoryStream(); + using (var writer = new Utf8JsonWriter(payloadStream)) + { + writer.WriteStartObject(); + writer.WriteString("iss", clientId); + writer.WriteString("sub", clientId); + writer.WriteString("aud", audience); + writer.WriteNumber("iat", now); + writer.WriteNumber("exp", now + 300); + writer.WriteString("jti", Guid.NewGuid()); + writer.WriteEndObject(); + } + + var payload = Base64UrlEncode(payloadStream.ToArray()); + var signingInput = Encoding.ASCII.GetBytes($"{header}.{payload}"); + using var key = ECDsa.Create(); + key.ImportFromPem(privateKeyPem); + var signature = key.SignData( + signingInput, + HashAlgorithmName.SHA256, + DSASignatureFormat.IeeeP1363FixedFieldConcatenation); + return $"{header}.{payload}.{Base64UrlEncode(signature)}"; + } + + private static async Task ReadJsonAsync( + HttpResponseMessage response, + CancellationToken cancellationToken) + { + using var stream = await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false); + using var document = await JsonDocument.ParseAsync(stream, cancellationToken: cancellationToken).ConfigureAwait(false); + return document.RootElement.Clone(); + } + + private static async Task ReadAccessTokenAsync( + HttpResponseMessage response, + CancellationToken cancellationToken) + { + var body = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false); + if (!response.IsSuccessStatusCode) + { + throw new HttpRequestException( + $"Client credentials token request failed with status {(int)response.StatusCode}: {body}"); + } + + using var document = JsonDocument.Parse(body); + if (!document.RootElement.TryGetProperty("access_token", out var accessToken) || + accessToken.GetString() is not { Length: > 0 } value) + { + throw new InvalidOperationException("The token response did not contain an access_token."); + } + + return value; + } + + private static string Base64UrlEncode(byte[] bytes) => + Convert.ToBase64String(bytes).TrimEnd('=').Replace('+', '-').Replace('/', '_'); + + private sealed record OAuthDiscovery( + string Resource, + string AuthorizationServer, + Uri TokenEndpoint, + IReadOnlyList Scopes); +} diff --git a/tests/ModelContextProtocol.ConformanceClient/Program.cs b/tests/ModelContextProtocol.ConformanceClient/Program.cs index b5e048dd0..718c782f9 100644 --- a/tests/ModelContextProtocol.ConformanceClient/Program.cs +++ b/tests/ModelContextProtocol.ConformanceClient/Program.cs @@ -3,6 +3,7 @@ using System.Text.Json; using System.Web; using Microsoft.Extensions.Logging; +using ModelContextProtocol.Authentication; using ModelContextProtocol.Client; using ModelContextProtocol.Protocol; @@ -36,6 +37,17 @@ }, }; +// The default client now prefers the 2026-07-28 protocol (probing with server/discover and +// falling back to an initialize handshake). The "initialize" and "sse-retry" scenarios +// specifically exercise the initialize handshake and SSE resumability (removed in the +// 2026-07-28 protocol) and strictly expect initialize as the first message. The alpha.9 +// json-schema-ref-no-deref server also uses a bundled Node transport that rejects the draft +// protocol header before tools/list. Pin these scenarios to the latest stable version. +if (scenario is "initialize" or "sse-retry" or "json-schema-ref-no-deref") +{ + options.ProtocolVersion = "2025-11-25"; +} + var consoleLoggerFactory = LoggerFactory.Create(builder => { builder.AddConsole(); @@ -60,28 +72,17 @@ var clientRedirectUri = new Uri($"http://localhost:{callbackPort}/callback"); // Read conformance context for scenarios that provide additional data (e.g., pre-registered credentials). -string? preRegisteredClientId = null; -string? preRegisteredClientSecret = null; var conformanceContext = Environment.GetEnvironmentVariable("MCP_CONFORMANCE_CONTEXT"); -if (!string.IsNullOrEmpty(conformanceContext)) -{ - using var doc = JsonDocument.Parse(conformanceContext); - if (doc.RootElement.TryGetProperty("client_id", out var clientIdEl)) - { - preRegisteredClientId = clientIdEl.GetString(); - } - if (doc.RootElement.TryGetProperty("client_secret", out var clientSecretEl)) - { - preRegisteredClientSecret = clientSecretEl.GetString(); - } -} +var parsedConformanceContext = ConformanceContext.Parse(conformanceContext); +var preRegisteredClientId = parsedConformanceContext?.GetString("client_id"); +var preRegisteredClientSecret = parsedConformanceContext?.GetString("client_secret"); var oauthOptions = new ModelContextProtocol.Authentication.ClientOAuthOptions { RedirectUri = clientRedirectUri, // Configure the metadata document URI for CIMD. ClientMetadataDocumentUri = new Uri("https://conformance-test.local/client-metadata.json"), - AuthorizationRedirectDelegate = (authUrl, redirectUri, ct) => HandleAuthorizationUrlAsync(authUrl, redirectUri, ct), + AuthorizationCallbackHandler = HandleAuthorizationUrlAsync, }; if (preRegisteredClientId is not null) @@ -98,12 +99,55 @@ }; } -var clientTransport = new HttpClientTransport(new() +var endpointUri = new Uri(endpoint); +HttpClientTransport clientTransport; +if (scenario is "auth/client-credentials-basic" or "auth/client-credentials-jwt") { - Endpoint = new Uri(endpoint), - TransportMode = HttpTransportMode.StreamableHttp, - OAuth = oauthOptions, -}, loggerFactory: consoleLoggerFactory); + var context = parsedConformanceContext + ?? throw new InvalidOperationException($"Scenario '{scenario}' requires MCP_CONFORMANCE_CONTEXT."); + var accessToken = await ConformanceOAuthHelpers.AcquireClientCredentialsTokenAsync( + endpointUri, + context, + usePrivateKeyJwt: scenario == "auth/client-credentials-jwt", + CancellationToken.None); + clientTransport = new HttpClientTransport( + new() + { + Endpoint = endpointUri, + TransportMode = HttpTransportMode.StreamableHttp, + }, + ConformanceOAuthHelpers.CreateBearerHttpClient(accessToken), + consoleLoggerFactory, + ownsHttpClient: true); +} +else if (scenario == "auth/enterprise-managed-authorization") +{ + var context = parsedConformanceContext + ?? throw new InvalidOperationException($"Scenario '{scenario}' requires MCP_CONFORMANCE_CONTEXT."); + var accessToken = await ConformanceOAuthHelpers.AcquireEnterpriseTokenAsync( + endpointUri, + context, + consoleLoggerFactory, + CancellationToken.None); + clientTransport = new HttpClientTransport( + new() + { + Endpoint = endpointUri, + TransportMode = HttpTransportMode.StreamableHttp, + }, + ConformanceOAuthHelpers.CreateBearerHttpClient(accessToken), + consoleLoggerFactory, + ownsHttpClient: true); +} +else +{ + clientTransport = new HttpClientTransport(new() + { + Endpoint = endpointUri, + TransportMode = HttpTransportMode.StreamableHttp, + OAuth = oauthOptions, + }, loggerFactory: consoleLoggerFactory); +} try { @@ -179,6 +223,170 @@ } break; } + case "auth/authorization-server-migration": + { + await mcpClient.ListToolsAsync(); + await mcpClient.ListToolsAsync(); + break; + } + case "auth/client-credentials-basic": + case "auth/client-credentials-jwt": + case "auth/enterprise-managed-authorization": + { + await mcpClient.ListToolsAsync(); + break; + } + case "http-standard-headers": + { + // List and call tools to test Mcp-Method and Mcp-Name headers + var tools = await mcpClient.ListToolsAsync(); + Console.WriteLine($"Available tools: {string.Join(", ", tools.Select(t => t.Name))}"); + + var tool = tools.FirstOrDefault(t => t.Name == "test_headers"); + if (tool is not null) + { + Console.WriteLine("Calling tool: test_headers"); + var result = await mcpClient.CallToolAsync(toolName: "test_headers", arguments: new Dictionary()); + success &= !(result.IsError == true); + } + + // List and get prompts to test Mcp-Method and Mcp-Name headers + var prompts = await mcpClient.ListPromptsAsync(); + Console.WriteLine($"Available prompts: {string.Join(", ", prompts.Select(p => p.Name))}"); + + foreach (var prompt in prompts) + { + Console.WriteLine($"Getting prompt: {prompt.Name}"); + try + { + await mcpClient.GetPromptAsync(prompt.Name); + } + catch (Exception ex) + { + Console.WriteLine($"Prompt get error (expected for test): {ex.Message}"); + } + } + + // List and read resources to test Mcp-Name with params.uri + var resources = await mcpClient.ListResourcesAsync(); + Console.WriteLine($"Available resources: {string.Join(", ", resources.Select(r => r.Uri))}"); + + foreach (var resource in resources) + { + Console.WriteLine($"Reading resource: {resource.Uri}"); + try + { + await mcpClient.ReadResourceAsync(resource.Uri); + } + catch (Exception ex) + { + Console.WriteLine($"Resource read error (expected for test): {ex.Message}"); + } + } + break; + } + case "http-custom-headers": + { + // List tools to discover x-mcp-header annotations (populates tool cache) + var tools = await mcpClient.ListToolsAsync(); + Console.WriteLine($"Available tools: {string.Join(", ", tools.Select(t => t.Name))}"); + + // Parse conformance context for tool calls + if (!string.IsNullOrEmpty(conformanceContext)) + { + using var contextDoc = JsonDocument.Parse(conformanceContext); + + // Support both "toolCalls" (array) and legacy "toolCall" (single object) + var toolCallElements = new List(); + if (contextDoc.RootElement.TryGetProperty("toolCalls", out var toolCallsArray) && + toolCallsArray.ValueKind == JsonValueKind.Array) + { + foreach (var item in toolCallsArray.EnumerateArray()) + { + toolCallElements.Add(item); + } + } + else if (contextDoc.RootElement.TryGetProperty("toolCall", out var toolCallEl)) + { + toolCallElements.Add(toolCallEl); + } + + foreach (var toolCallEl in toolCallElements) + { + var toolName = toolCallEl.TryGetProperty("name", out var nameEl) + ? nameEl.GetString() ?? "test_custom_headers" + : "test_custom_headers"; + + Dictionary toolCallArgs = new(); + if (toolCallEl.TryGetProperty("arguments", out var argsEl)) + { + foreach (var prop in argsEl.EnumerateObject()) + { + object? value = prop.Value.ValueKind switch + { + JsonValueKind.String => prop.Value.GetString(), + JsonValueKind.Number => prop.Value.TryGetInt64(out var l) ? l : prop.Value.GetDouble(), + JsonValueKind.True => true, + JsonValueKind.False => false, + JsonValueKind.Null => null, + _ => prop.Value.GetRawText(), + }; + toolCallArgs[prop.Name] = value; + } + } + + Console.WriteLine($"Calling tool: {toolName} with {toolCallArgs.Count} arguments"); + var result = await mcpClient.CallToolAsync(toolName: toolName, arguments: toolCallArgs); + success &= !(result.IsError == true); + } + } + break; + } + case "http-invalid-tool-headers": + { + // List tools — the client should filter out tools with invalid x-mcp-header annotations + var tools = await mcpClient.ListToolsAsync(); + Console.WriteLine($"Available tools after filtering: {string.Join(", ", tools.Select(t => t.Name))}"); + + // Only call valid_tool — invalid tools should have been excluded + var validTool = tools.FirstOrDefault(t => t.Name == "valid_tool"); + if (validTool is not null) + { + Console.WriteLine("Calling valid_tool"); + var result = await mcpClient.CallToolAsync(toolName: "valid_tool", arguments: new Dictionary + { + { "region", "us-east1" } + }); + success &= !(result.IsError == true); + } + else + { + Console.WriteLine("ERROR: valid_tool was not found in the filtered tool list"); + success = false; + } + break; + } + case "json-schema-ref-no-deref": + { + // SEP-2106: listing tools must not dereference network $refs in a tool's + // inputSchema — the scenario's canary endpoint observes any such fetch. + await mcpClient.ListToolsAsync(); + break; + } + case "sep-2322-client-request-state": + { + // SEP-2322 (MRTR): drive the client's input-required auto-loop. The mock + // inspects the raw tools/call params: requestState echoed byte-exact (and + // omitted when the server sent none), a fresh JSON-RPC id per retry, no + // MRTR params bleeding into the unrelated call, and a missing resultType + // parsing as a terminal (complete) result. + await mcpClient.ListToolsAsync(); + await mcpClient.CallToolAsync(toolName: "test_mrtr_echo_state", arguments: new Dictionary()); + await mcpClient.CallToolAsync(toolName: "test_mrtr_unrelated", arguments: new Dictionary()); + await mcpClient.CallToolAsync(toolName: "test_mrtr_no_state", arguments: new Dictionary()); + await mcpClient.CallToolAsync(toolName: "test_mrtr_no_result_type", arguments: new Dictionary()); + break; + } default: // No extra processing for other scenarios break; @@ -199,8 +407,12 @@ // Copied from ProtectedMcpClient sample // Simulate a user opening the browser and logging in // Copied from OAuthTestBase -static async Task HandleAuthorizationUrlAsync(Uri authorizationUrl, Uri redirectUri, CancellationToken cancellationToken) +static async Task HandleAuthorizationUrlAsync( + AuthorizationCallbackContext authorizationContext, + CancellationToken cancellationToken) { + var authorizationUrl = authorizationContext.AuthorizationUri; + Console.WriteLine("Starting OAuth authorization flow..."); Console.WriteLine($"Simulating opening browser to: {authorizationUrl}"); @@ -214,16 +426,35 @@ if (location is not null && !string.IsNullOrEmpty(location.Query)) { - // Parse query string to extract "code" parameter + // Parse query string to extract "code", "state", and "iss" parameters var query = location.Query.TrimStart('?'); + string? code = null; + string? state = null; + string? iss = null; foreach (var pair in query.Split('&')) { var parts = pair.Split('=', 2); - if (parts.Length == 2 && parts[0] == "code") + if (parts.Length == 2) { - return HttpUtility.UrlDecode(parts[1]); + if (parts[0] == "code") + { + code = HttpUtility.UrlDecode(parts[1]); + } + else if (parts[0] == "state") + { + state = HttpUtility.UrlDecode(parts[1]); + } + else if (parts[0] == "iss") + { + iss = HttpUtility.UrlDecode(parts[1]); + } } } + + if (code is not null) + { + return new AuthorizationResult { Code = code, State = state, Iss = iss }; + } } return null; diff --git a/tests/ModelContextProtocol.ConformanceServer/ModelContextProtocol.ConformanceServer.csproj b/tests/ModelContextProtocol.ConformanceServer/ModelContextProtocol.ConformanceServer.csproj index 15b2c87f2..dffffa9d3 100644 --- a/tests/ModelContextProtocol.ConformanceServer/ModelContextProtocol.ConformanceServer.csproj +++ b/tests/ModelContextProtocol.ConformanceServer/ModelContextProtocol.ConformanceServer.csproj @@ -5,6 +5,7 @@ enable enable Exe + $(NoWarn);MCP9006 @@ -14,6 +15,7 @@ + diff --git a/tests/ModelContextProtocol.ConformanceServer/Program.cs b/tests/ModelContextProtocol.ConformanceServer/Program.cs index 017ec235f..73f63821e 100644 --- a/tests/ModelContextProtocol.ConformanceServer/Program.cs +++ b/tests/ModelContextProtocol.ConformanceServer/Program.cs @@ -3,7 +3,9 @@ using ConformanceServer.Tools; using ModelContextProtocol.Protocol; using ModelContextProtocol.Server; +using ModelContextProtocol.Extensions.Tasks; using System.Collections.Concurrent; +using System.Diagnostics; using System.Text.Json; namespace ModelContextProtocol.ConformanceServer; @@ -20,17 +22,58 @@ public static async Task MainAsync(string[] args, ILoggerProvider? loggerProvide builder.Logging.AddProvider(loggerProvider); } - // Dictionary of session IDs to a set of resource URIs they are subscribed to - // The value is a ConcurrentDictionary used as a thread-safe HashSet - // because .NET does not have a built-in concurrent HashSet - ConcurrentDictionary> subscriptions = new(); + // Configure the default, stateful MCP server (served at "/"). + ConfigureConformanceMcpServer(builder.Services, stateless: false); - builder.Services.AddDistributedMemoryCache(); - builder.Services + var app = builder.Build(); + + // Also expose a stateless MCP server at "/stateless" so a single conformance server can + // serve both the legacy stateful lifecycle (at "/") and the SEP-2575 stateless lifecycle + // (at "/stateless", which the 2026-07-28 "caching" (SEP-2549) and MRTR (SEP-2322) + // scenarios require) from one Kestrel port. + HandleStatelessMcp(app); + + app.MapMcp(); + + app.MapGet("/health", () => "Healthy"); + + await app.RunAsync(cancellationToken); + } + + // Registers the conformance MCP server (tools, prompts, resources, filters, and handlers) + // into the given service collection. Shared by the stateful ("/") and stateless ("/stateless") + // servers, which expose identical behavior except that only the stateful server registers the + // resource-subscription handlers (see below). + private static void ConfigureConformanceMcpServer( + IServiceCollection services, + bool stateless) + { + services.AddDistributedMemoryCache(); + var mcpServerBuilder = services .AddMcpServer() - .WithHttpTransport() + .WithHttpTransport(options => options.Stateless = stateless) .WithDistributedCacheEventStreamStore() + .WithTasks( + new InMemoryMcpTaskStore + { + DefaultPollIntervalMs = 50, + DefaultTimeToLive = TimeSpan.FromMinutes(5), + }, + options => options.ExecutionModeSelector = request => + request.Params?.Name switch + { + "slow_compute" or "protocol_error_job" or "confirm_delete" or "multi_input" + => McpTaskExecutionMode.Optional, + "failing_job" + => McpTaskExecutionMode.Required, + "test_tool_with_task" when request.Params.InputResponses is { Count: > 0 } + => McpTaskExecutionMode.Required, + _ => McpTaskExecutionMode.Synchronous, + }) .WithTools() + .WithTools() + .WithTools() + .WithTools() .WithTools([ConformanceTools.CreateJsonSchema202012Tool()]) .WithRequestFilters(filters => filters.AddCallToolFilter(next => async (request, cancellationToken) => { @@ -45,36 +88,48 @@ public static async Task MainAsync(string[] args, ILoggerProvider? loggerProvide } return result; - })) - .WithPrompts() - .WithResources() - .WithSubscribeToResourcesHandler(async (ctx, ct) => + }) + // SEP-2549: advertise TTL/cacheScope caching hints on cacheable results. The + // conformance server's tools, prompts, resources, and resource templates are the + // same for every caller, so they are cacheable with a "public" scope. + .AddListToolsFilter(next => async (request, cancellationToken) => { - if (ctx.Server.SessionId == null) - { - throw new McpException("Cannot add subscription for server with null SessionId"); - } - if (ctx.Params.Uri is { } uri) - { - var sessionSubscriptions = subscriptions.GetOrAdd(ctx.Server.SessionId, _ => new()); - sessionSubscriptions.TryAdd(uri, 0); - } - - return new EmptyResult(); + var result = await next(request, cancellationToken); + result.TimeToLive = TimeSpan.FromMinutes(5); + result.CacheScope = CacheScope.Public; + return result; }) - .WithUnsubscribeFromResourcesHandler(async (ctx, ct) => + .AddListPromptsFilter(next => async (request, cancellationToken) => { - if (ctx.Server.SessionId == null) - { - throw new McpException("Cannot remove subscription for server with null SessionId"); - } - if (ctx.Params.Uri is { } uri) - { - subscriptions[ctx.Server.SessionId].TryRemove(uri, out _); - } - - return new EmptyResult(); + var result = await next(request, cancellationToken); + result.TimeToLive = TimeSpan.FromMinutes(5); + result.CacheScope = CacheScope.Public; + return result; }) + .AddListResourcesFilter(next => async (request, cancellationToken) => + { + var result = await next(request, cancellationToken); + result.TimeToLive = TimeSpan.FromMinutes(5); + result.CacheScope = CacheScope.Public; + return result; + }) + .AddListResourceTemplatesFilter(next => async (request, cancellationToken) => + { + var result = await next(request, cancellationToken); + result.TimeToLive = TimeSpan.FromMinutes(5); + result.CacheScope = CacheScope.Public; + return result; + }) + .AddReadResourceFilter(next => async (request, cancellationToken) => + { + var result = await next(request, cancellationToken); + result.TimeToLive = TimeSpan.FromMinutes(1); + result.CacheScope = CacheScope.Public; + return result; + })) + .WithPrompts() + .WithPrompts() + .WithResources() .WithCompleteHandler(async (ctx, ct) => { // Basic completion support - returns empty array for conformance @@ -103,13 +158,70 @@ public static async Task MainAsync(string[] args, ILoggerProvider? loggerProvide return new EmptyResult(); }); - var app = builder.Build(); + // Resource subscriptions require a stable SessionId to key the subscription table and a + // persistent SSE stream to deliver notifications/resources/updated, neither of which + // exists in the stateless lifecycle. Only the stateful server registers these handlers, + // so only it advertises the resources.subscribe capability. + if (!stateless) + { + // Dictionary of session IDs to a set of resource URIs they are subscribed to. The + // value is a ConcurrentDictionary used as a thread-safe HashSet because .NET does not + // have a built-in concurrent HashSet. + ConcurrentDictionary> subscriptions = new(); - app.MapMcp(); + mcpServerBuilder + .WithSubscribeToResourcesHandler(async (ctx, ct) => + { + if (ctx.Server.SessionId == null) + { + throw new McpException("Cannot add subscription for server with null SessionId"); + } + if (ctx.Params.Uri is { } uri) + { + var sessionSubscriptions = subscriptions.GetOrAdd(ctx.Server.SessionId, _ => new()); + sessionSubscriptions.TryAdd(uri, 0); + } - app.MapGet("/health", () => "Healthy"); + return new EmptyResult(); + }) + .WithUnsubscribeFromResourcesHandler(async (ctx, ct) => + { + if (ctx.Server.SessionId == null) + { + throw new McpException("Cannot remove subscription for server with null SessionId"); + } + if (ctx.Params.Uri is { } uri) + { + subscriptions[ctx.Server.SessionId].TryRemove(uri, out _); + } - await app.RunAsync(cancellationToken); + return new EmptyResult(); + }); + } + } + + // Maps a second MCP server, configured for the stateless lifecycle, at "/stateless". It is + // built in its own ServiceCollection so its DI (and HttpServerTransportOptions) stays isolated + // from the stateful server registered on the main host. Adapted from + // ModelContextProtocol.TestSseServer.Program.HandleStatelessMcp. + private static void HandleStatelessMcp(WebApplication app) + { + var services = new ServiceCollection(); + services.AddLogging(); + services.AddSingleton(app.Services.GetRequiredService()); + services.AddSingleton(app.Services.GetRequiredService()); + services.AddSingleton(app.Services.GetRequiredService()); + services.AddRoutingCore(); + + ConfigureConformanceMcpServer(services, stateless: true); + + var statelessApp = new ApplicationBuilder(services.BuildServiceProvider()); + statelessApp.UseRouting(); + statelessApp.UseEndpoints(endpoints => endpoints.MapMcp("/stateless")); + + // Terminal middleware that serves "/stateless" requests the main host's routing did not + // match. Registered before app.MapMcp() so the stateful endpoints still win for "/". + app.Run(statelessApp.Build()); } public static async Task Main(string[] args) diff --git a/tests/ModelContextProtocol.ConformanceServer/Prompts/IncompleteResultPrompts.cs b/tests/ModelContextProtocol.ConformanceServer/Prompts/IncompleteResultPrompts.cs new file mode 100644 index 000000000..0fcb05711 --- /dev/null +++ b/tests/ModelContextProtocol.ConformanceServer/Prompts/IncompleteResultPrompts.cs @@ -0,0 +1,68 @@ +#pragma warning disable MCPEXP001 // MRTR (SEP-2322) is experimental. + +using ModelContextProtocol; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.ComponentModel; +using System.Text.Json; + +namespace ConformanceServer.Prompts; + +/// +/// Prompt implementing the SEP-2322 D1 conformance scenario (incomplete-result-non-tool-request), +/// proving that prompts/get can return an just like +/// tools/call. +/// +[McpServerPromptType] +public sealed class IncompleteResultPrompts +{ + [McpServerPrompt(Name = "test_input_required_result_prompt")] + [Description("SEP-2322 D1: prompts/get returns InputRequiredResult until user_context is supplied.")] + public static GetPromptResult IncompleteResultPrompt(RequestContext context) + { + if (context.Params!.InputResponses is { } responses && + responses.TryGetValue("user_context", out var response)) + { + var elicit = response.Deserialize(InputResponse.ElicitResultJsonTypeInfo); + var contextValue = TryReadString(elicit?.Content, "context") ?? "(unknown)"; + return new GetPromptResult + { + Description = "Prompt customized with elicited user context.", + Messages = + [ + new PromptMessage + { + Role = Role.User, + Content = new TextContentBlock { Text = $"Please continue using context: {contextValue}" }, + }, + ], + }; + } + + throw new InputRequiredException( + new Dictionary + { + ["user_context"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "What context should the prompt use?", + RequestedSchema = new ElicitRequestParams.RequestSchema + { + Properties = new Dictionary + { + ["context"] = new ElicitRequestParams.StringSchema(), + }, + Required = ["context"], + }, + }), + }); + } + + private static string? TryReadString(IDictionary? content, string key) + { + if (content is null || !content.TryGetValue(key, out var element)) + { + return null; + } + return element.ValueKind == JsonValueKind.String ? element.GetString() : element.ToString(); + } +} diff --git a/tests/ModelContextProtocol.ConformanceServer/Tools/ConformanceTaskTools.cs b/tests/ModelContextProtocol.ConformanceServer/Tools/ConformanceTaskTools.cs new file mode 100644 index 000000000..4441c1d39 --- /dev/null +++ b/tests/ModelContextProtocol.ConformanceServer/Tools/ConformanceTaskTools.cs @@ -0,0 +1,102 @@ +#pragma warning disable MCPEXP001 // MRTR (SEP-2322) is experimental. + +using ModelContextProtocol; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.ComponentModel; + +namespace ConformanceServer.Tools; + +[McpServerToolType] +public sealed class ConformanceTaskTools +{ + [McpServerTool(Name = "greet")] + [Description("Returns a synchronous greeting.")] + public static string Greet(string name) => $"Hello, {name}!"; + + [McpServerTool(Name = "slow_compute")] + [Description("Completes after the requested number of seconds.")] + public static async Task SlowCompute(int seconds, string? label, CancellationToken cancellationToken) + { + await Task.Delay(TimeSpan.FromSeconds(seconds), cancellationToken); + return $"Computed {label ?? "result"}"; + } + + [McpServerTool(Name = "failing_job")] + [Description("Produces a tool execution error.")] + public static async Task FailingJob(CancellationToken cancellationToken) + { + await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationToken); + throw new Exception("The conformance task failed."); + } + + [McpServerTool(Name = "protocol_error_job")] + [Description("Produces a protocol-level error.")] + public static string ProtocolErrorJob() => + throw new McpProtocolException("The conformance task encountered a protocol error.", McpErrorCode.InternalError); + + [McpServerTool(Name = "confirm_delete")] + [Description("Waits for elicitation before confirming deletion.")] + public static async Task ConfirmDelete( + McpServer server, + string filename, + CancellationToken cancellationToken) + { + var result = await server.ElicitAsync(CreateConfirmationRequest($"Delete {filename}?"), cancellationToken); + return result.Action == "accept" ? $"Deleted {filename}" : $"Did not delete {filename}"; + } + + [McpServerTool(Name = "multi_input")] + [Description("Waits for two independent elicitation responses.")] + public static async Task MultiInput(McpServer server, CancellationToken cancellationToken) + { + await Task.WhenAll( + server.ElicitAsync(CreateConfirmationRequest("Confirm the first operation."), cancellationToken).AsTask(), + server.ElicitAsync(CreateConfirmationRequest("Confirm the second operation."), cancellationToken).AsTask()); + return "Both inputs received."; + } + + [McpServerTool(Name = "test_tool_with_task")] + [Description("Collects input synchronously, then completes through a task.")] + public static string ToolWithTask(RequestContext context) + { + if (context.Params!.InputResponses is { } responses && + responses.TryGetValue("user_name", out var response)) + { + var elicitation = response.Deserialize(InputResponse.ElicitResultJsonTypeInfo); + var name = elicitation?.Content?["name"].GetString() ?? "world"; + return $"Hello, {name}!"; + } + + throw new InputRequiredException( + new Dictionary + { + ["user_name"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "What is your name?", + RequestedSchema = new ElicitRequestParams.RequestSchema + { + Properties = + { + ["name"] = new ElicitRequestParams.StringSchema(), + }, + Required = ["name"], + }, + }), + }); + } + + private static ElicitRequestParams CreateConfirmationRequest(string message) => + new() + { + Message = message, + RequestedSchema = new ElicitRequestParams.RequestSchema + { + Properties = + { + ["confirm"] = new ElicitRequestParams.BooleanSchema(), + }, + Required = ["confirm"], + }, + }; +} diff --git a/tests/ModelContextProtocol.ConformanceServer/Tools/ConformanceTools.cs b/tests/ModelContextProtocol.ConformanceServer/Tools/ConformanceTools.cs index d6db6f626..bef403404 100644 --- a/tests/ModelContextProtocol.ConformanceServer/Tools/ConformanceTools.cs +++ b/tests/ModelContextProtocol.ConformanceServer/Tools/ConformanceTools.cs @@ -442,4 +442,13 @@ public static string TestReconnection() // and the client must reconnect to get the result. return "Reconnection test completed successfully"; } + + [McpServerTool(Name = "test_header_tool")] + [Description("A tool with x-mcp-header annotations for conformance testing")] + public static string TestHeaderTool( + [McpHeader("Region"), Description("The deployment region")] string region, + [Description("The query to execute")] string query) + { + return $"Executed in region {region}: {query}"; + } } \ No newline at end of file diff --git a/tests/ModelContextProtocol.ConformanceServer/Tools/IncompleteResultTools.cs b/tests/ModelContextProtocol.ConformanceServer/Tools/IncompleteResultTools.cs new file mode 100644 index 000000000..99a770527 --- /dev/null +++ b/tests/ModelContextProtocol.ConformanceServer/Tools/IncompleteResultTools.cs @@ -0,0 +1,412 @@ +#pragma warning disable MCPEXP001 // MRTR (SEP-2322) is experimental. + +using ModelContextProtocol; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.ComponentModel; +using System.Security.Cryptography; +using System.Text; +using System.Text.Json; +using System.Text.Json.Nodes; + +namespace ConformanceServer.Tools; + +/// +/// Tools implementing the SEP-2322 (MRTR / IncompleteResult) conformance scenarios from +/// incomplete-result.ts in the conformance test suite. All tools use the +/// API so they work both in stateful sessions with +/// MRTR-aware clients and in legacy-resolve mode (the SDK will translate exceptions to the +/// proper wire shape based on negotiated protocol version). +/// +[McpServerToolType] +public sealed class IncompleteResultTools +{ + // ──── A1: Basic Elicitation ───────────────────────────────────────────── + [McpServerTool(Name = "test_input_required_result_elicitation")] + [Description("SEP-2322 A1: returns InputRequiredResult with elicitation/create keyed 'user_name'.")] + public static CallToolResult ToolWithElicitation(RequestContext context) + { + if (context.Params!.InputResponses is { } responses && + responses.TryGetValue("user_name", out var response)) + { + var elicit = response.Deserialize(InputResponse.ElicitResultJsonTypeInfo); + var name = TryReadString(elicit?.Content, "name") ?? "world"; + return TextResult($"Hello, {name}!"); + } + + throw new InputRequiredException( + new Dictionary + { + ["user_name"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "What is your name?", + RequestedSchema = new ElicitRequestParams.RequestSchema + { + Properties = new Dictionary + { + ["name"] = new ElicitRequestParams.StringSchema(), + }, + Required = ["name"], + }, + }), + }); + } + + // ──── A2: Basic Sampling ──────────────────────────────────────────────── + [McpServerTool(Name = "test_input_required_result_sampling")] + [Description("SEP-2322 A2: returns InputRequiredResult with sampling/createMessage keyed 'capital_question'.")] + public static CallToolResult ToolWithSampling(RequestContext context) + { + if (context.Params!.InputResponses is { } responses && + responses.TryGetValue("capital_question", out var response)) + { + var text = response.Deserialize(InputResponse.CreateMessageResultJsonTypeInfo)?.Content?.OfType().FirstOrDefault()?.Text ?? "(no text)"; + return TextResult($"Sampling said: {text}"); + } + + throw new InputRequiredException( + new Dictionary + { + ["capital_question"] = InputRequest.ForSampling(new CreateMessageRequestParams + { + Messages = + [ + new SamplingMessage + { + Role = Role.User, + Content = [new TextContentBlock { Text = "What is the capital of France?" }], + }, + ], + MaxTokens = 100, + }), + }); + } + + // ──── A3: Basic ListRoots ─────────────────────────────────────────────── + [McpServerTool(Name = "test_input_required_result_list_roots")] + [Description("SEP-2322 A3: returns InputRequiredResult with roots/list keyed 'client_roots'.")] + public static CallToolResult ToolWithListRoots(RequestContext context) + { + if (context.Params!.InputResponses is { } responses && + responses.TryGetValue("client_roots", out var response)) + { + var count = response.Deserialize(InputResponse.ListRootsResultJsonTypeInfo)?.Roots?.Count ?? 0; + return TextResult($"Got {count} root(s) from the client."); + } + + throw new InputRequiredException( + new Dictionary + { + ["client_roots"] = InputRequest.ForRootsList(new ListRootsRequestParams()), + }); + } + + // ──── B1: requestState round-trip ─────────────────────────────────────── + private const string RequestStateToken = "mrtr-conformance-state-v1"; + + [McpServerTool(Name = "test_input_required_result_request_state")] + [Description("SEP-2322 B1: round-trips a requestState string; R2 echoes 'state-ok' on success.")] + public static CallToolResult ToolWithRequestState(RequestContext context) + { + if (context.Params!.RequestState is { } state) + { + if (state != RequestStateToken) + { + return TextResult("state-mismatch: client echoed an unexpected requestState"); + } + return TextResult("state-ok: server received and validated the echoed requestState"); + } + + throw new InputRequiredException( + inputRequests: new Dictionary + { + ["confirm"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "Please confirm", + RequestedSchema = new ElicitRequestParams.RequestSchema + { + Properties = new Dictionary + { + ["ok"] = new ElicitRequestParams.BooleanSchema(), + }, + Required = ["ok"], + }, + }), + }, + requestState: RequestStateToken); + } + + // ──── B2: Multiple input requests in one round ────────────────────────── + [McpServerTool(Name = "test_input_required_result_multiple_inputs")] + [Description("SEP-2322 B2: returns 3 simultaneous inputRequests (elicit + sampling + roots) plus requestState.")] + public static CallToolResult ToolWithMultipleInputs(RequestContext context) + { + if (context.Params!.InputResponses is { } responses && responses.Count >= 3) + { + return TextResult("multiple-inputs-ok: received elicit + sampling + roots responses"); + } + + throw new InputRequiredException( + inputRequests: new Dictionary + { + ["user_name"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "What is your name?", + RequestedSchema = new ElicitRequestParams.RequestSchema + { + Properties = new Dictionary + { + ["name"] = new ElicitRequestParams.StringSchema(), + }, + Required = ["name"], + }, + }), + ["greeting"] = InputRequest.ForSampling(new CreateMessageRequestParams + { + Messages = + [ + new SamplingMessage + { + Role = Role.User, + Content = [new TextContentBlock { Text = "Generate a greeting" }], + }, + ], + MaxTokens = 50, + }), + ["client_roots"] = InputRequest.ForRootsList(new ListRootsRequestParams()), + }, + requestState: "multi-input-state"); + } + + // ──── B3: Multi-round (R1 -> incomplete, R2 -> incomplete (new state), R3 -> complete) ───── + [McpServerTool(Name = "test_input_required_result_multi_round")] + [Description("SEP-2322 B3: three-round flow whose requestState changes between rounds.")] + public static CallToolResult ToolWithMultiRound(RequestContext context) + { + var state = context.Params!.RequestState; + if (state is null) + { + // Round 1: elicit name. + throw new InputRequiredException( + inputRequests: new Dictionary + { + ["step1"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "Step 1: What is your name?", + RequestedSchema = new ElicitRequestParams.RequestSchema + { + Properties = new Dictionary + { + ["name"] = new ElicitRequestParams.StringSchema(), + }, + Required = ["name"], + }, + }), + }, + requestState: "round-1"); + } + + if (state == "round-1") + { + // Round 2: elicit color (new state). + throw new InputRequiredException( + inputRequests: new Dictionary + { + ["step2"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "Step 2: What is your favorite color?", + RequestedSchema = new ElicitRequestParams.RequestSchema + { + Properties = new Dictionary + { + ["color"] = new ElicitRequestParams.StringSchema(), + }, + Required = ["color"], + }, + }), + }, + requestState: "round-2"); + } + + // Round 3: complete. + return TextResult("multi-round-ok"); + } + + // ──── C1: Missing/wrong inputResponses key - re-request rather than error ──── + [McpServerTool(Name = "test_incomplete_result_elicitation")] + [Description("SEP-2322 C1: re-requests missing inputResponses key instead of erroring.")] + public static CallToolResult ToolForMissingResponse(RequestContext context) + { + if (context.Params!.InputResponses is { } responses && + responses.TryGetValue("user_name", out var response)) + { + var elicit = response.Deserialize(InputResponse.ElicitResultJsonTypeInfo); + var name = TryReadString(elicit?.Content, "name") ?? "world"; + return TextResult($"Hello, {name}!"); + } + + // Either no inputResponses or wrong key - re-request via a fresh InputRequiredResult + // (per SEP-2322 recommendation in scenario C1). + throw new InputRequiredException( + new Dictionary + { + ["user_name"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "What is your name?", + RequestedSchema = new ElicitRequestParams.RequestSchema + { + Properties = new Dictionary + { + ["name"] = new ElicitRequestParams.StringSchema(), + }, + Required = ["name"], + }, + }), + }); + } + + // ──── A12: Tampered requestState rejection (integrity protection) ─────── + // SEP-2322 recommends integrity-protecting requestState (e.g. an HMAC signature) + // so a client cannot forge or mutate it. R1 returns a signed requestState; R2 with + // a tampered requestState fails verification and surfaces a JSON-RPC error (not an + // isError CallToolResult and not a re-prompt). + private static readonly byte[] s_requestStateKey = Encoding.UTF8.GetBytes("mrtr-conformance-hmac-key-v1"); + + [McpServerTool(Name = "test_input_required_result_tampered_state")] + [Description("SEP-2322 A12: R1 returns an HMAC-signed requestState; R2 rejects a tampered requestState with a JSON-RPC error.")] + public static CallToolResult ToolWithTamperedState(RequestContext context) + { + if (context.Params!.RequestState is { } state) + { + if (!VerifyRequestState(state)) + { + throw new McpProtocolException( + "requestState failed integrity verification (tampered or invalid signature).", + McpErrorCode.InvalidParams); + } + + return TextResult("tampered-state-ok: requestState integrity verified"); + } + + throw new InputRequiredException( + inputRequests: new Dictionary + { + ["confirm"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "Please confirm", + RequestedSchema = new ElicitRequestParams.RequestSchema + { + Properties = new Dictionary + { + ["ok"] = new ElicitRequestParams.BooleanSchema(), + }, + Required = ["ok"], + }, + }), + }, + requestState: SignRequestState()); + } + + // ──── A13: Respect client capabilities ────────────────────────────────── + // Per SEP-2575 the client declares its capabilities in the per-request + // _meta['io.modelcontextprotocol/clientCapabilities'] envelope (surfaced on + // JsonRpcMessageContext.ClientCapabilities). The server MUST only emit inputRequests + // for capabilities the client advertised on this request. + [McpServerTool(Name = "test_input_required_result_capabilities")] + [Description("SEP-2322 A13: returns inputRequests only for the capabilities the client declared in per-request _meta.")] + public static CallToolResult ToolWithCapabilityCheck(RequestContext context) + { + if (context.Params!.InputResponses is { Count: > 0 }) + { + return TextResult("capability-check-ok: received input responses"); + } + + var capabilities = context.JsonRpcRequest.Context?.ClientCapabilities; + var inputRequests = new Dictionary(); + + if (capabilities?.Sampling is not null) + { + inputRequests["capital_question"] = InputRequest.ForSampling(new CreateMessageRequestParams + { + Messages = + [ + new SamplingMessage + { + Role = Role.User, + Content = [new TextContentBlock { Text = "What is the capital of France?" }], + }, + ], + MaxTokens = 100, + }); + } + + if (capabilities?.Elicitation is not null) + { + inputRequests["user_name"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "What is your name?", + RequestedSchema = new ElicitRequestParams.RequestSchema + { + Properties = new Dictionary + { + ["name"] = new ElicitRequestParams.StringSchema(), + }, + Required = ["name"], + }, + }); + } + + if (capabilities?.Roots is not null) + { + inputRequests["client_roots"] = InputRequest.ForRootsList(new ListRootsRequestParams()); + } + + if (inputRequests.Count == 0) + { + return TextResult("capability-check-ok: client declared no MRTR-capable features"); + } + + throw new InputRequiredException(inputRequests); + } + + private static string SignRequestState() + { + var nonce = Guid.NewGuid().ToString("N"); + return $"{nonce}.{ComputeSignature(nonce)}"; + } + + private static bool VerifyRequestState(string state) + { + var separator = state.LastIndexOf('.'); + if (separator <= 0 || separator == state.Length - 1) + { + return false; + } + + var nonce = state[..separator]; + var signature = state[(separator + 1)..]; + return CryptographicOperations.FixedTimeEquals( + Encoding.UTF8.GetBytes(signature), + Encoding.UTF8.GetBytes(ComputeSignature(nonce))); + } + + private static string ComputeSignature(string nonce) + { + using var hmac = new HMACSHA256(s_requestStateKey); + return Convert.ToHexString(hmac.ComputeHash(Encoding.UTF8.GetBytes(nonce))); + } + + private static CallToolResult TextResult(string text) => new() + { + Content = [new TextContentBlock { Text = text }], + }; + + private static string? TryReadString(IDictionary? content, string key) + { + if (content is null || !content.TryGetValue(key, out var element)) + { + return null; + } + return element.ValueKind == JsonValueKind.String ? element.GetString() : element.ToString(); + } +} diff --git a/tests/ModelContextProtocol.ConformanceServer/Tools/Sep2575DiagnosticTools.cs b/tests/ModelContextProtocol.ConformanceServer/Tools/Sep2575DiagnosticTools.cs new file mode 100644 index 000000000..b95ecdd24 --- /dev/null +++ b/tests/ModelContextProtocol.ConformanceServer/Tools/Sep2575DiagnosticTools.cs @@ -0,0 +1,62 @@ +using ModelContextProtocol; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.ComponentModel; + +namespace ConformanceServer.Tools; + +/// +/// Diagnostic tools exercised by the SEP-2575 server-stateless conformance scenario. Each +/// tool exists so the harness can observe a framework behavior (capability enforcement, response +/// stream discipline, per-request log gating) that plain application tools never trigger. +/// +[McpServerToolType] +public class Sep2575DiagnosticTools +{ + /// + /// Requires the client to have declared the sampling capability in the per-request + /// _meta/io.modelcontextprotocol/clientCapabilities. Used to verify the server rejects + /// undeclared-capability calls with MissingRequiredClientCapabilityError (-32021). + /// + [McpServerTool(Name = "test_missing_capability")] + [Description("Requires the sampling client capability; used to verify MissingRequiredClientCapabilityError (-32021) (SEP-2575)")] + public static string MissingCapability(RequestContext context) + { + if (context.Server.ClientCapabilities?.Sampling is not null) + { + return "Client declared the sampling capability; tool executed."; + } + + throw new MissingRequiredClientCapabilityException( + new ClientCapabilities { Sampling = new() }, + "sampling capability required but not declared by client"); + } + + /// + /// Returns a plain result. Per SEP-2575 the response stream must carry no independent top-level + /// JSON-RPC requests; a plain response trivially satisfies this. The scenario declares no + /// elicitation capability, so this tool must not initiate an elicitation. + /// + [McpServerTool(Name = "test_streaming_elicitation")] + [Description("Streams only result frames; used to verify response streams carry no independent JSON-RPC requests (SEP-2575)")] + public static string StreamingElicitation() + { + return "stream observed: result frames only, no top-level requests"; + } + + /// + /// Attempts to emit a log message through the client-logger pipeline, which gates on the + /// per-request _meta/io.modelcontextprotocol/logLevel. When the client did not opt in, + /// no notifications/message may be sent for the request. + /// + [McpServerTool(Name = "test_logging_tool")] + [Description("Attempts to emit a log message; the framework must drop it when the client did not set _meta.../logLevel (SEP-2575)")] + public static string LoggingTool(RequestContext context) + { +#pragma warning disable MCP9004 // AsClientLoggerProvider is deprecated with the legacy logging/setLevel flow but remains the gated client-log pipeline. + ILogger logger = context.Server.AsClientLoggerProvider().CreateLogger(nameof(Sep2575DiagnosticTools)); +#pragma warning restore MCP9004 + logger.LogInformation("test_logging_tool executed"); + return "Log attempted; framework gates on _meta.../logLevel."; + } +} diff --git a/tests/ModelContextProtocol.TestOAuthServer/ClientRegistrationRequest.cs b/tests/ModelContextProtocol.TestOAuthServer/ClientRegistrationRequest.cs index 50592bbea..1e9c9fc07 100644 --- a/tests/ModelContextProtocol.TestOAuthServer/ClientRegistrationRequest.cs +++ b/tests/ModelContextProtocol.TestOAuthServer/ClientRegistrationRequest.cs @@ -55,6 +55,12 @@ internal sealed class ClientRegistrationRequest [JsonPropertyName("scope")] public string? Scope { get; init; } + /// + /// Gets or sets the OIDC application type ("web" or "native"). + /// + [JsonPropertyName("application_type")] + public string? ApplicationType { get; init; } + /// /// Gets or sets the contacts for the client. /// diff --git a/tests/ModelContextProtocol.TestOAuthServer/JagTokenExchangeResponse.cs b/tests/ModelContextProtocol.TestOAuthServer/JagTokenExchangeResponse.cs new file mode 100644 index 000000000..cae8a943d --- /dev/null +++ b/tests/ModelContextProtocol.TestOAuthServer/JagTokenExchangeResponse.cs @@ -0,0 +1,38 @@ +using System.Text.Json.Serialization; + +namespace ModelContextProtocol.TestOAuthServer; + +/// +/// Represents the token exchange response for the Identity Assertion JWT Authorization Grant (ID-JAG) +/// per RFC 8693 / SEP-990. +/// +internal sealed class JagTokenExchangeResponse +{ + /// + /// Gets or sets the issued JWT Authorization Grant (JAG). + /// Despite the field name "access_token" (required by RFC 8693), this contains a JAG JWT, + /// not an OAuth access token. + /// + [JsonPropertyName("access_token")] + public required string AccessToken { get; init; } + + /// + /// Gets or sets the type of security token issued. + /// For SEP-990, this MUST be "urn:ietf:params:oauth:token-type:id-jag". + /// + [JsonPropertyName("issued_token_type")] + public required string IssuedTokenType { get; init; } + + /// + /// Gets or sets the token type. + /// For SEP-990, this MUST be "N_A" per RFC 8693 §2.2.1 because the JAG is not an access token. + /// + [JsonPropertyName("token_type")] + public required string TokenType { get; init; } + + /// + /// Gets or sets the lifetime in seconds of the issued JAG. + /// + [JsonPropertyName("expires_in")] + public int? ExpiresIn { get; init; } +} diff --git a/tests/ModelContextProtocol.TestOAuthServer/OAuthJsonContext.cs b/tests/ModelContextProtocol.TestOAuthServer/OAuthJsonContext.cs index 6caaaea01..e8c98275a 100644 --- a/tests/ModelContextProtocol.TestOAuthServer/OAuthJsonContext.cs +++ b/tests/ModelContextProtocol.TestOAuthServer/OAuthJsonContext.cs @@ -5,6 +5,7 @@ namespace ModelContextProtocol.TestOAuthServer; [JsonSerializable(typeof(OAuthServerMetadata))] [JsonSerializable(typeof(AuthorizationServerMetadata))] [JsonSerializable(typeof(TokenResponse))] +[JsonSerializable(typeof(JagTokenExchangeResponse))] [JsonSerializable(typeof(JsonWebKeySet))] [JsonSerializable(typeof(JsonWebKey))] [JsonSerializable(typeof(TokenIntrospectionResponse))] diff --git a/tests/ModelContextProtocol.TestOAuthServer/OAuthServerMetadata.cs b/tests/ModelContextProtocol.TestOAuthServer/OAuthServerMetadata.cs index c05a45ba2..744ab0e08 100644 --- a/tests/ModelContextProtocol.TestOAuthServer/OAuthServerMetadata.cs +++ b/tests/ModelContextProtocol.TestOAuthServer/OAuthServerMetadata.cs @@ -12,7 +12,8 @@ internal sealed class OAuthServerMetadata /// REQUIRED. The authorization server's issuer identifier, which is a URL that uses the "https" scheme and has no query or fragment components. /// [JsonPropertyName("issuer")] - public required string Issuer { get; init; } + [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)] + public string? Issuer { get; init; } /// /// Gets or sets the authorization endpoint URL. @@ -178,4 +179,11 @@ internal sealed class OAuthServerMetadata [JsonPropertyName("client_id_metadata_document_supported")] [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)] public bool? ClientIdMetadataDocumentSupported { get; init; } + + /// + /// Gets or sets a value indicating whether authorization responses contain an issuer parameter. + /// + [JsonPropertyName("authorization_response_iss_parameter_supported")] + [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)] + public bool? AuthorizationResponseIssParameterSupported { get; init; } } diff --git a/tests/ModelContextProtocol.TestOAuthServer/Program.cs b/tests/ModelContextProtocol.TestOAuthServer/Program.cs index e882ecbef..73663dc94 100644 --- a/tests/ModelContextProtocol.TestOAuthServer/Program.cs +++ b/tests/ModelContextProtocol.TestOAuthServer/Program.cs @@ -28,6 +28,7 @@ public sealed class Program private readonly ConcurrentDictionary _clients = new(); private readonly ConcurrentQueue _metadataRequests = new(); + private int _authorizationCodeTokenRequestCount; private readonly RSA _rsa; private readonly string _keyId; @@ -57,6 +58,18 @@ public Program(ILoggerProvider? loggerProvider = null, IConnectionListenerFactor // Track if we've already issued an already-expired token for the CanAuthenticate_WithTokenRefresh test which uses the test-refresh-client registration. public bool HasRefreshedToken { get; set; } + /// + /// Gets or sets a value indicating whether the server supports the Enterprise Managed + /// Authorization (SEP-990) flow, including the IdP token-exchange endpoint and the + /// JWT-bearer grant type at the token endpoint. + /// + /// + /// When true, the server registers enterprise test clients and activates the + /// /idp/token endpoint (RFC 8693 token exchange) and the + /// urn:ietf:params:oauth:grant-type:jwt-bearer grant type (RFC 7523). + /// + public bool EnterpriseSupportEnabled { get; set; } + /// /// Gets or sets a value indicating whether the authorization server /// advertises support for client ID metadata documents in its discovery @@ -78,9 +91,62 @@ public Program(ILoggerProvider? loggerProvider = null, IConnectionListenerFactor /// public bool ExpectResource { get; set; } = true; + /// + /// Gets or sets a value indicating whether the authorization server advertises support for + /// offline_access in its scopes_supported metadata. This simulates an OIDC-flavored + /// authorization server that issues refresh tokens when the client requests the offline_access scope. + /// + /// + /// The default value is false. + /// + public bool IncludeOfflineAccessInMetadata { get; set; } + + /// + /// Gets or sets a value indicating whether authorization server metadata includes an issuer. + /// + public bool IncludeIssuerInMetadata { get; set; } = true; + + /// + /// Gets or sets an issuer value that overrides the authorization server's metadata issuer. + /// + public string? MetadataIssuerOverride { get; set; } + + /// + /// Gets or sets a value indicating whether the authorization server advertises RFC 9207 support. + /// + public bool AuthorizationResponseIssParameterSupported { get; set; } + + /// + /// Gets or sets the issuer included in authorization responses, or to omit it. + /// + public string? AuthorizationResponseIssuer { get; set; } + + /// + /// Gets or sets the code challenge methods advertised by metadata endpoints. + /// + /// + /// The default value is ["S256"]. + /// + public List? CodeChallengeMethodsSupported { get; set; } = ["S256"]; + + /// + /// Gets the set of metadata paths that should omit code_challenge_methods_supported from their + /// response, simulating a server whose discovery endpoints advertise differing PKCE support. + /// + public HashSet MetadataPathsWithoutPkceSupport { get; } = new(StringComparer.OrdinalIgnoreCase); + public HashSet DisabledMetadataPaths { get; } = new(StringComparer.OrdinalIgnoreCase); public IReadOnlyCollection MetadataRequests => _metadataRequests.ToArray(); + /// Gets the number of authorization-code token exchange requests received. + public int AuthorizationCodeTokenRequestCount => Volatile.Read(ref _authorizationCodeTokenRequestCount); + + /// Gets the scope field from the most recent Dynamic Client Registration request. + public string? LastRegistrationScope { get; private set; } + + /// Gets the application_type field from the most recent Dynamic Client Registration request. + public string? LastApplicationType { get; private set; } + /// /// Entry point for the application. /// @@ -158,6 +224,25 @@ public async Task RunServerAsync(string[]? args = null, CancellationToken cancel RedirectUris = ["http://localhost:1179/callback"], }; + // Enterprise Auth (SEP-990) clients. + // The IdP client is used to authenticate calls to /idp/token (token exchange). + // The MCP client is used to authenticate calls to /token (jwt-bearer grant). + // Neither needs redirect URIs because neither uses the authorization code flow. + _clients["enterprise-idp-client"] = new ClientInfo + { + ClientId = "enterprise-idp-client", + ClientSecret = "enterprise-idp-secret", + RequiresClientSecret = true, + RedirectUris = [], + }; + _clients["enterprise-mcp-client"] = new ClientInfo + { + ClientId = "enterprise-mcp-client", + ClientSecret = "enterprise-mcp-secret", + RequiresClientSecret = true, + RedirectUris = [], + }; + // The MCP spec tells the client to use /.well-known/oauth-authorization-server but AddJwtBearer looks for // /.well-known/openid-configuration by default. // @@ -181,21 +266,26 @@ IResult HandleMetadataRequest(HttpContext context, string? issuerPath = null) var metadata = new OAuthServerMetadata { - Issuer = $"{_url}{issuerPath}", + Issuer = IncludeIssuerInMetadata ? MetadataIssuerOverride ?? $"{_url}{issuerPath}" : null, AuthorizationEndpoint = $"{_url}/authorize", TokenEndpoint = $"{_url}/token", JwksUri = $"{_url}/.well-known/jwks.json", ResponseTypesSupported = ["code"], SubjectTypesSupported = ["public"], IdTokenSigningAlgValuesSupported = ["RS256"], - ScopesSupported = ["openid", "profile", "email", "mcp:tools"], + ScopesSupported = IncludeOfflineAccessInMetadata + ? ["openid", "profile", "email", "mcp:tools", "offline_access"] + : ["openid", "profile", "email", "mcp:tools"], TokenEndpointAuthMethodsSupported = ["client_secret_post"], ClaimsSupported = ["sub", "iss", "name", "email", "aud"], - CodeChallengeMethodsSupported = ["S256"], + CodeChallengeMethodsSupported = MetadataPathsWithoutPkceSupport.Contains(context.Request.Path) + ? null + : CodeChallengeMethodsSupported, GrantTypesSupported = ["authorization_code", "refresh_token"], IntrospectionEndpoint = $"{_url}/introspect", RegistrationEndpoint = $"{_url}/register", ClientIdMetadataDocumentSupported = ClientIdMetadataDocumentSupported, + AuthorizationResponseIssParameterSupported = AuthorizationResponseIssParameterSupported ? true : null, }; return Results.Ok(metadata); @@ -327,6 +417,10 @@ IResult HandleMetadataRequest(HttpContext context, string? issuerPath = null) { redirectUrl += $"&state={Uri.EscapeDataString(state)}"; } + if (!string.IsNullOrEmpty(AuthorizationResponseIssuer)) + { + redirectUrl += $"&iss={Uri.EscapeDataString(AuthorizationResponseIssuer)}"; + } return Results.Redirect(redirectUrl); }); @@ -348,10 +442,18 @@ IResult HandleMetadataRequest(HttpContext context, string? issuerPath = null) type: "https://tools.ietf.org/html/rfc6749#section-5.2"); } + // Read grant type early so we can skip resource validation for grant types that + // don't use the resource parameter (e.g. jwt-bearer where the resource is embedded + // inside the JWT assertion itself). + var grant_type = form["grant_type"].ToString(); + // Validate resource in accordance with RFC 8707. // When ExpectResource is false, the resource parameter must be absent (legacy mode). + // RFC 7523 JWT-bearer assertions carry the target resource inside the JWT itself, + // so we skip the form-level resource check for that grant type. var resource = form["resource"].ToString(); - if (ExpectResource ? (string.IsNullOrEmpty(resource) || !ValidResources.Contains(resource)) : !string.IsNullOrEmpty(resource)) + if (grant_type != "urn:ietf:params:oauth:grant-type:jwt-bearer" && + (ExpectResource ? (string.IsNullOrEmpty(resource) || !ValidResources.Contains(resource)) : !string.IsNullOrEmpty(resource))) { return Results.BadRequest(new OAuthErrorResponse { @@ -360,9 +462,9 @@ IResult HandleMetadataRequest(HttpContext context, string? issuerPath = null) }); } - var grant_type = form["grant_type"].ToString(); if (grant_type == "authorization_code") { + Interlocked.Increment(ref _authorizationCodeTokenRequestCount); var code = form["code"].ToString(); var code_verifier = form["code_verifier"].ToString(); var redirect_uri = form["redirect_uri"].ToString(); @@ -437,6 +539,45 @@ IResult HandleMetadataRequest(HttpContext context, string? issuerPath = null) HasRefreshedToken = true; return Results.Ok(response); } + else if (grant_type == "urn:ietf:params:oauth:grant-type:jwt-bearer") + { + if (!EnterpriseSupportEnabled) + { + return Results.BadRequest(new OAuthErrorResponse + { + Error = "unsupported_grant_type", + ErrorDescription = "JWT bearer grant is not enabled on this server." + }); + } + + var assertion = form["assertion"].ToString(); + if (string.IsNullOrEmpty(assertion)) + { + return Results.BadRequest(new OAuthErrorResponse + { + Error = "invalid_request", + ErrorDescription = "assertion is required for jwt-bearer grant" + }); + } + + // Extract the target resource from the JAG payload (set during /idp/token). + // Fall back to ValidResources[0] so the token is still usable in tests even + // if the resource claim is absent. + var jagResource = ExtractJwtClaim(assertion, "resource"); + if (string.IsNullOrEmpty(jagResource) || !ValidResources.Contains(jagResource)) + { + jagResource = ValidResources.Length > 0 ? ValidResources[0] : null; + } + + var resourceUri = jagResource is not null ? new Uri(jagResource) : null; + var scope = form["scope"].ToString(); + var scopes = string.IsNullOrEmpty(scope) + ? ["mcp:tools"] + : scope.Split(' ', StringSplitOptions.RemoveEmptyEntries).ToList(); + + var response = GenerateJwtTokenResponse(client.ClientId, scopes, resourceUri); + return Results.Ok(response); + } else { return Results.BadRequest(new OAuthErrorResponse @@ -447,6 +588,77 @@ IResult HandleMetadataRequest(HttpContext context, string? issuerPath = null) } }); + // IdP token-exchange endpoint (RFC 8693) for Enterprise Managed Authorization (SEP-990). + // Exchanges an enterprise ID token (from SSO) for a JWT Authorization Grant (JAG) + // that can subsequently be used at the /token endpoint via the jwt-bearer grant. + app.MapPost("/idp/token", async (HttpContext context) => + { + if (!EnterpriseSupportEnabled) + { + return Results.NotFound(); + } + + var form = await context.Request.ReadFormAsync(); + + // Authenticate the IdP client. + var client = AuthenticateClient(context, form); + if (client == null) + { + context.Response.StatusCode = 401; + return Results.Problem( + statusCode: 401, + title: "Unauthorized", + detail: "Invalid client credentials", + type: "https://tools.ietf.org/html/rfc6749#section-5.2"); + } + + var grantType = form["grant_type"].ToString(); + if (grantType != "urn:ietf:params:oauth:grant-type:token-exchange") + { + return Results.BadRequest(new OAuthErrorResponse + { + Error = "unsupported_grant_type", + ErrorDescription = "Only urn:ietf:params:oauth:grant-type:token-exchange is supported on this endpoint." + }); + } + + var subjectToken = form["subject_token"].ToString(); + if (string.IsNullOrEmpty(subjectToken)) + { + return Results.BadRequest(new OAuthErrorResponse + { + Error = "invalid_request", + ErrorDescription = "subject_token is required." + }); + } + + var requestedTokenType = form["requested_token_type"].ToString(); + if (requestedTokenType != "urn:ietf:params:oauth:token-type:id-jag") + { + return Results.BadRequest(new OAuthErrorResponse + { + Error = "invalid_request", + ErrorDescription = "requested_token_type must be urn:ietf:params:oauth:token-type:id-jag." + }); + } + + var audience = form["audience"].ToString(); + var resourceParam = form["resource"].ToString(); + + // Generate a JAG JWT signed with the server's RSA key. + // The JAG encodes the intended audience (MCP AS) and resource (MCP server) so + // the /token endpoint can later issue a correctly-scoped access token. + var jag = GenerateJagJwt(audience, resourceParam); + + return Results.Ok(new JagTokenExchangeResponse + { + AccessToken = jag, + IssuedTokenType = "urn:ietf:params:oauth:token-type:id-jag", + TokenType = "N_A", + ExpiresIn = 300, + }); + }); + // Introspection endpoint app.MapPost("/introspect", async (HttpContext context) => { @@ -501,6 +713,9 @@ IResult HandleMetadataRequest(HttpContext context, string? issuerPath = null) }); } + LastRegistrationScope = registrationRequest.Scope; + LastApplicationType = registrationRequest.ApplicationType; + // Validate redirect URIs are provided if (registrationRequest.RedirectUris.Count == 0) { @@ -675,6 +890,70 @@ private TokenResponse GenerateJwtTokenResponse(string clientId, List sco }; } + /// + /// Generates a JWT Authorization Grant (JAG) signed with the server's RSA key. + /// The JAG encodes the target audience (MCP AS URL) and the resource (MCP server URL). + /// + private string GenerateJagJwt(string audience, string resource) + { + var expiresIn = TimeSpan.FromMinutes(5); + var issuedAt = DateTimeOffset.UtcNow; + var expiresAt = issuedAt.Add(expiresIn); + + var header = new Dictionary + { + { "alg", "RS256" }, + { "typ", "JWT" }, + { "kid", _keyId }, + }; + + var payload = new Dictionary + { + { "iss", _url }, + { "sub", "enterprise-user" }, + { "aud", audience }, + { "resource", resource }, // carried through so /token can issue the right audience + { "jti", Guid.NewGuid().ToString() }, + { "iat", issuedAt.ToUnixTimeSeconds().ToString(System.Globalization.CultureInfo.InvariantCulture) }, + { "exp", expiresAt.ToUnixTimeSeconds().ToString(System.Globalization.CultureInfo.InvariantCulture) }, + }; + + var headerJson = System.Text.Json.JsonSerializer.Serialize(header, OAuthJsonContext.Default.DictionaryStringString); + var payloadJson = System.Text.Json.JsonSerializer.Serialize(payload, OAuthJsonContext.Default.DictionaryStringString); + + var headerBase64 = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(headerJson)); + var payloadBase64 = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(payloadJson)); + + var dataToSign = $"{headerBase64}.{payloadBase64}"; + var signature = _rsa.SignData(Encoding.UTF8.GetBytes(dataToSign), HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1); + + return $"{headerBase64}.{payloadBase64}.{WebEncoders.Base64UrlEncode(signature)}"; + } + + /// + /// Decodes a JWT payload (without signature verification) and returns the value of + /// , or null if the claim is absent or the JWT is malformed. + /// + private static string? ExtractJwtClaim(string jwt, string claimName) + { + var parts = jwt.Split('.'); + if (parts.Length < 2) + { + return null; + } + + try + { + var payloadJson = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(parts[1])); + var payload = System.Text.Json.JsonSerializer.Deserialize(payloadJson, OAuthJsonContext.Default.DictionaryStringString); + return payload?.TryGetValue(claimName, out var value) == true ? value : null; + } + catch + { + return null; + } + } + /// /// Generates a random token for authorization code or refresh token. /// diff --git a/tests/ModelContextProtocol.TestServer/Program.cs b/tests/ModelContextProtocol.TestServer/Program.cs index 9cb963a96..6812fe5d5 100644 --- a/tests/ModelContextProtocol.TestServer/Program.cs +++ b/tests/ModelContextProtocol.TestServer/Program.cs @@ -34,6 +34,13 @@ private static ILoggerFactory CreateLoggerFactory() private static async Task Main(string[] args) { + if (args.Contains("--echo-cli-arg-and-exit")) + { + Console.Error.WriteLine($"CLI_ARG:{JsonSerializer.Serialize(ParseCliArgument(args))}"); + Console.Error.Flush(); + return; + } + Log.Logger.Information("Starting server..."); string? cliArg = ParseCliArgument(args); @@ -162,27 +169,6 @@ private static void ConfigureTools(McpServerOptions options, string? cliArg) """), }, new Tool - { - Name = "longRunning", - Description = "Simulates a long-running operation that supports task-based execution.", - InputSchema = JsonElement.Parse(""" - { - "type": "object", - "properties": { - "durationMs": { - "type": "number", - "description": "Duration of the operation in milliseconds" - } - }, - "required": ["durationMs"] - } - """), - Execution = new ToolExecution - { - TaskSupport = ToolTaskSupport.Optional - } - }, - new Tool { Name = "crash", Description = "Terminates the server process with a specified exit code.", @@ -245,19 +231,6 @@ private static void ConfigureTools(McpServerOptions options, string? cliArg) Content = [new TextContentBlock { Text = cliArg ?? "null" }] }; } - else if (request.Params.Name == "longRunning") - { - if (request.Params.Arguments is null || !request.Params.Arguments.TryGetValue("durationMs", out var durationMsValue)) - { - throw new McpProtocolException("Missing required argument 'durationMs'", McpErrorCode.InvalidParams); - } - int durationMs = Convert.ToInt32(durationMsValue.GetRawText()); - await Task.Delay(durationMs, cancellationToken); - return new CallToolResult - { - Content = [new TextContentBlock { Text = $"Long-running operation completed after {durationMs}ms" }] - }; - } else if (request.Params.Name == "crash") { if (request.Params.Arguments is null || !request.Params.Arguments.TryGetValue("exitCode", out var exitCodeValue)) @@ -503,7 +476,7 @@ private static void ConfigureResources(McpServerOptions options) } ResourceContents contents = resourceContents.FirstOrDefault(r => r.Uri == request.Params.Uri) - ?? throw new McpProtocolException($"Resource not found: '{request.Params.Uri}'", McpErrorCode.ResourceNotFound); + ?? throw new McpProtocolException($"Resource not found: '{request.Params.Uri}'", McpErrorCode.InvalidParams); return new ReadResourceResult { diff --git a/tests/ModelContextProtocol.TestSseServer/Program.cs b/tests/ModelContextProtocol.TestSseServer/Program.cs index a36a0a6e0..030f05657 100644 --- a/tests/ModelContextProtocol.TestSseServer/Program.cs +++ b/tests/ModelContextProtocol.TestSseServer/Program.cs @@ -1,4 +1,5 @@ using Microsoft.AspNetCore.Connections; +using ModelContextProtocol.AspNetCore; using ModelContextProtocol.Protocol; using ModelContextProtocol.Server; using Serilog; @@ -146,27 +147,6 @@ static CreateMessageRequestParams CreateRequestSamplingParams(string context, st } """), }, - new Tool - { - Name = "longRunning", - Description = "Simulates a long-running operation that supports task-based execution.", - InputSchema = JsonElement.Parse(""" - { - "type": "object", - "properties": { - "durationMs": { - "type": "number", - "description": "Duration of the operation in milliseconds" - } - }, - "required": ["durationMs"] - } - """), - Execution = new ToolExecution - { - TaskSupport = ToolTaskSupport.Optional - } - } ] }; }, @@ -212,19 +192,6 @@ static CreateMessageRequestParams CreateRequestSamplingParams(string context, st Content = [new TextContentBlock { Text = $"LLM sampling result: {sampleResult.Content.OfType().FirstOrDefault()?.Text}" }] }; } - else if (request.Params.Name == "longRunning") - { - if (request.Params.Arguments is null || !request.Params.Arguments.TryGetValue("durationMs", out var durationMsValue)) - { - throw new McpProtocolException("Missing required argument 'durationMs'", McpErrorCode.InvalidParams); - } - int durationMs = Convert.ToInt32(durationMsValue.ToString()); - await Task.Delay(durationMs, cancellationToken); - return new CallToolResult - { - Content = [new TextContentBlock { Text = $"Long-running operation completed after {durationMs}ms" }] - }; - } else { throw new McpProtocolException($"Unknown tool: '{request.Params.Name}'", McpErrorCode.InvalidParams); @@ -307,7 +274,7 @@ static CreateMessageRequestParams CreateRequestSamplingParams(string context, st } ResourceContents? contents = resourceContents.FirstOrDefault(r => r.Uri == request.Params.Uri) ?? - throw new McpProtocolException($"Resource not found: '{request.Params.Uri}'", McpErrorCode.ResourceNotFound); + throw new McpProtocolException($"Resource not found: '{request.Params.Uri}'", McpErrorCode.InvalidParams); return new ReadResourceResult { @@ -412,7 +379,7 @@ private static void HandleStatelessMcp(IApplicationBuilder app) serviceCollection.AddSingleton(app.ApplicationServices.GetRequiredService()); serviceCollection.AddRoutingCore(); - serviceCollection.AddMcpServer(ConfigureOptions).WithHttpTransport(options => options.Stateless = true); + serviceCollection.AddMcpServer(ConfigureOptions).WithHttpTransport(options => options.SessionMode = HttpServerSessionMode.Stateless); var appBuilder = new ApplicationBuilder(serviceCollection.BuildServiceProvider()); appBuilder.UseRouting(); @@ -459,7 +426,13 @@ public static async Task MainAsync(string[] args, ILoggerProvider? loggerProvide } builder.Services.AddMcpServer(ConfigureOptions) - .WithHttpTransport(options => options.EnableLegacySse = true); + .WithHttpTransport(options => + { + // The test fixture exercises legacy stateful behaviors (SSE + session-id flows). + // Set SessionMode = HttpServerSessionMode.Stateful explicitly since sessions are required. + options.SessionMode = HttpServerSessionMode.Stateful; + options.EnableLegacySse = true; + }); var app = builder.Build(); diff --git a/tests/ModelContextProtocol.Tests/Authentication/ClientOAuthProviderApplicationTypeTests.cs b/tests/ModelContextProtocol.Tests/Authentication/ClientOAuthProviderApplicationTypeTests.cs new file mode 100644 index 000000000..9c38963eb --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Authentication/ClientOAuthProviderApplicationTypeTests.cs @@ -0,0 +1,41 @@ +using ModelContextProtocol.Authentication; +using ModelContextProtocol.Client; + +namespace ModelContextProtocol.Tests.Authentication; + +// ClientOAuthProvider is internal; construct it indirectly via HttpClientTransport +// to verify DCR application_type validation is deferred until DCR is selected. +public class ClientOAuthProviderApplicationTypeTests +{ + private static readonly Uri ServerEndpoint = new("https://server.example.com/mcp"); + + private static HttpClientTransportOptions BuildOptions(string redirectUri, string? explicitApplicationType = null) + { + return new HttpClientTransportOptions + { + Endpoint = ServerEndpoint, + OAuth = new ClientOAuthOptions + { + RedirectUri = new Uri(redirectUri), + DynamicClientRegistration = new DynamicClientRegistrationOptions + { + ApplicationType = explicitApplicationType, + }, + }, + }; + } + + [Theory] + [InlineData("http://localhost:8080/callback", "web")] + [InlineData("https://example.com/callback", "native")] + public void Constructor_Defers_ApplicationTypeValidation_UntilDynamicRegistration( + string redirectUri, string explicitType) + { + var options = BuildOptions(redirectUri, explicitType); + + using var httpClient = new HttpClient(); + _ = new HttpClientTransport(options, httpClient); + + Assert.Equal(explicitType, options.OAuth!.DynamicClientRegistration!.ApplicationType); + } +} diff --git a/tests/ModelContextProtocol.Tests/Client/July2026ProtocolConnectionTests.cs b/tests/ModelContextProtocol.Tests/Client/July2026ProtocolConnectionTests.cs new file mode 100644 index 000000000..e6817574e --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Client/July2026ProtocolConnectionTests.cs @@ -0,0 +1,138 @@ +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.Text.Json; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.Tests.Client; + +/// +/// Connection-flow tests for the 2026-07-28 protocol revision (SEP-2575 + SEP-2567) +/// on . A client that requests +/// calls server/discover rather than +/// initialize. +/// +public class July2026ProtocolConnectionTests : ClientServerTestBase +{ + private const string LatestStableVersion = McpProtocolVersions.November2025ProtocolVersion; + + public July2026ProtocolConnectionTests(ITestOutputHelper testOutputHelper) + : base(testOutputHelper, startServer: false) + { + } + + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + services.Configure(options => + { + options.ServerInfo = new Implementation { Name = nameof(July2026ProtocolConnectionTests), Version = "1.0" }; + }); + } + + [Fact] + public async Task Client_RequestingJuly2026Protocol_NegotiatesIt() + { + StartServer(); + + var options = new McpClientOptions { ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion }; + await using var client = await CreateMcpClientForServer(options); + + Assert.Equal(McpProtocolVersions.July2026ProtocolVersion, client.NegotiatedProtocolVersion); + Assert.NotNull(client.ServerCapabilities); + Assert.Equal(nameof(July2026ProtocolConnectionTests), client.ServerInfo.Name); + } + + [Fact] + public async Task Client_RequestingInitializeHandshakeVersion_NegotiatesIt() + { + StartServer(); + + await using var client = await CreateMcpClientForServer(new McpClientOptions { ProtocolVersion = LatestStableVersion }); + + Assert.NotEqual(McpProtocolVersions.July2026ProtocolVersion, client.NegotiatedProtocolVersion); + } + + [Fact] + public async Task Client_AllowsDiscoverResultWithoutServerInfo() + { + ConfigureDiscoverServerInfo(meta => meta.Remove(MetaKeys.ServerInfo)); + StartServer(); + + var options = new McpClientOptions { ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion }; + await using var client = await CreateMcpClientForServer(options); + + Assert.Equal(McpProtocolVersions.July2026ProtocolVersion, client.NegotiatedProtocolVersion); + Assert.Throws(() => _ = client.ServerInfo); + } + + [Fact] + public async Task Client_RejectsMalformedDiscoverServerInfo() + { + ConfigureDiscoverServerInfo(meta => meta[MetaKeys.ServerInfo] = "invalid"); + StartServer(); + + var options = new McpClientOptions { ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion }; + await Assert.ThrowsAsync(() => CreateMcpClientForServer(options)); + } + + [Fact] + public async Task Client_RejectsNullDiscoverServerInfo() + { + ConfigureDiscoverServerInfo(meta => meta[MetaKeys.ServerInfo] = null); + StartServer(); + + var options = new McpClientOptions { ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion }; + await Assert.ThrowsAsync(() => CreateMcpClientForServer(options)); + } + + [Fact] + public async Task InitializeHandshakeClient_CannotCallServerDiscover() + { + // server/discover is registered unconditionally so the protocol boundary filter can return a structured + // error, but initialize-handshake clients cannot use it after negotiating an older protocol version. + StartServer(); + + await using var client = await CreateMcpClientForServer(new McpClientOptions { ProtocolVersion = LatestStableVersion }); + + var exception = await Assert.ThrowsAsync(async () => + await client.SendRequestAsync( + new JsonRpcRequest { Method = RequestMethods.ServerDiscover }, + TestContext.Current.CancellationToken)); + + Assert.Equal(McpErrorCode.MethodNotFound, exception.ErrorCode); + Assert.Contains(RequestMethods.ServerDiscover, exception.Message, StringComparison.Ordinal); + } + + [Fact] + public async Task ServerDiscover_IncludesJuly2026ProtocolVersion() + { + StartServer(); + + await using var client = await CreateMcpClientForServer(); + + var response = await client.SendRequestAsync( + new JsonRpcRequest { Method = RequestMethods.ServerDiscover }, + TestContext.Current.CancellationToken); + + var discoverResult = JsonSerializer.Deserialize(response.Result, McpJsonUtilities.DefaultOptions); + Assert.NotNull(discoverResult); + Assert.Equal("complete", discoverResult.ResultType); + Assert.Equal([McpProtocolVersions.July2026ProtocolVersion], discoverResult.SupportedVersions); + } + + private void ConfigureDiscoverServerInfo(Action configure) + { + McpServerBuilder.WithMessageFilters(filters => filters.AddOutgoingFilter(next => async (context, cancellationToken) => + { + if (context.JsonRpcMessage is JsonRpcResponse { Result: JsonObject result } && + result["supportedVersions"] is not null && + result["_meta"] is JsonObject meta) + { + configure(meta); + } + + await next(context, cancellationToken); + })); + } +} diff --git a/tests/ModelContextProtocol.Tests/Client/July2026ProtocolFallbackTests.cs b/tests/ModelContextProtocol.Tests/Client/July2026ProtocolFallbackTests.cs new file mode 100644 index 000000000..fed5df665 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Client/July2026ProtocolFallbackTests.cs @@ -0,0 +1,521 @@ +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Tests.Utils; +using System.Diagnostics; +using System.Net; +using System.Text; +using System.Text.Json; +using System.Text.Json.Nodes; +using System.Threading.Channels; + +namespace ModelContextProtocol.Tests.Client; + +/// +/// Regression tests for the fallback from the 2026-07-28 protocol revision to an initialize-handshake protocol in +/// . With default options (ProtocolVersion = null) the client prefers +/// 2026-07-28 but probes with server/discover, falls back to the initialize +/// handshake when the server only supports that path, and accepts whatever supported protocol version the +/// server negotiates. Pinning ProtocolVersion to 2026-07-28 instead makes it the +/// minimum too, so the client refuses to fall back. +/// +/// +/// The originally shipped initialize-handshake fallback logic compared the server's response +/// against the requested version and threw when an initialize-handshake server downgraded to (say) +/// "2025-06-18", even though negotiation succeeded. These tests guard against that regression. +/// +public class July2026ProtocolFallbackTests(ITestOutputHelper testOutputHelper) : LoggedTest(testOutputHelper) +{ + [Fact] + public async Task Client_OnMethodNotFound_FallsBackTo_Initialize_AcceptsDowngradedVersion() + { + var ct = TestContext.Current.CancellationToken; + await using var transport = new InitializeHandshakeServerTestTransport(serverNegotiatedVersion: McpProtocolVersions.June2025ProtocolVersion); + + // Default options (ProtocolVersion = null) prefer 2026-07-28 but allow automatic fallback. + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions(), + loggerFactory: LoggerFactory, cancellationToken: ct); + + Assert.True(transport.ServerDiscoverProbed); + Assert.True(transport.InitializeReceived); + Assert.Equal(McpProtocolVersions.November2025ProtocolVersion, transport.InitializeProtocolVersion); + Assert.Equal(McpProtocolVersions.June2025ProtocolVersion, client.NegotiatedProtocolVersion); + } + + [Fact] + public async Task Client_OnInvalidParams_FallsBackTo_Initialize() + { + var ct = TestContext.Current.CancellationToken; + await using var transport = new InitializeHandshakeServerTestTransport( + serverNegotiatedVersion: McpProtocolVersions.November2025ProtocolVersion, + probeErrorCode: (int)McpErrorCode.InvalidParams); + + // Default options (ProtocolVersion = null) prefer 2026-07-28 but allow automatic fallback. + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions(), + loggerFactory: LoggerFactory, cancellationToken: ct); + + Assert.True(transport.InitializeReceived); + Assert.Equal(McpProtocolVersions.November2025ProtocolVersion, transport.InitializeProtocolVersion); + Assert.Equal(McpProtocolVersions.November2025ProtocolVersion, client.NegotiatedProtocolVersion); + } + + [Fact] + public async Task Client_OnInitializeFallback_RejectsPerRequestMetadataInitializeResponse() + { + var ct = TestContext.Current.CancellationToken; + await using var transport = new InitializeHandshakeServerTestTransport( + serverNegotiatedVersion: McpProtocolVersions.July2026ProtocolVersion); + + var exception = await Assert.ThrowsAnyAsync(async () => + { + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions(), + loggerFactory: LoggerFactory, cancellationToken: ct); + }); + + Assert.IsType(exception); + Assert.True(transport.InitializeReceived); + Assert.Equal(McpProtocolVersions.November2025ProtocolVersion, transport.InitializeProtocolVersion); + Assert.Contains("mismatch", exception.Message, StringComparison.OrdinalIgnoreCase); + } + + [Fact] + public async Task Client_WithPinnedJuly2026Version_RefusesFallback_ToInitializeHandshakeServer() + { + var ct = TestContext.Current.CancellationToken; + await using var transport = new InitializeHandshakeServerTestTransport(serverNegotiatedVersion: McpProtocolVersions.June2025ProtocolVersion); + + var exception = await Assert.ThrowsAnyAsync(async () => + { + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions + { + // Pinning the version makes it the minimum too, so the client refuses to fall back. + ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion, + }, loggerFactory: LoggerFactory, cancellationToken: ct); + }); + + Assert.IsType(exception); + Assert.Contains("2026-07-28", exception.Message, StringComparison.OrdinalIgnoreCase); + } + + [Fact] + public async Task InitializeHandshakeClient_WithExplicitPin_StillRequires_ExactVersionMatch() + { + var ct = TestContext.Current.CancellationToken; + // Server responds with a DIFFERENT version than the one the user pinned. + await using var transport = new InitializeHandshakeServerTestTransport(serverNegotiatedVersion: McpProtocolVersions.March2025ProtocolVersion); + + var exception = await Assert.ThrowsAnyAsync(async () => + { + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions + { + ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion, + }, loggerFactory: LoggerFactory, cancellationToken: ct); + }); + + Assert.IsType(exception); + Assert.Contains("mismatch", exception.Message, StringComparison.OrdinalIgnoreCase); + } + + [Fact] + public async Task Client_OnHeaderMismatch_Surfaces_NoFallback() + { + // The peer uses per-request metadata (returns the spec-defined -32020 HeaderMismatch on the probe). + // Falling back to initialize would just produce another malformed envelope. + // Verify the connect-time logic surfaces the error to the caller instead of falling back. + var ct = TestContext.Current.CancellationToken; + await using var transport = new InitializeHandshakeServerTestTransport( + serverNegotiatedVersion: McpProtocolVersions.November2025ProtocolVersion, + probeErrorCode: (int)McpErrorCode.HeaderMismatch); + + var exception = await Assert.ThrowsAnyAsync(async () => + { + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions + { + ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion, + }, loggerFactory: LoggerFactory, cancellationToken: ct); + }); + + Assert.True(transport.ServerDiscoverProbed); + Assert.False(transport.InitializeReceived); + Assert.Equal(McpErrorCode.HeaderMismatch, ((McpProtocolException)exception).ErrorCode); + } + + [Fact] + public async Task Client_OnUnsupportedProtocolVersion_WithPerRequestMetadataVersion_RetriesDiscover() + { + var ct = TestContext.Current.CancellationToken; + await using var transport = new PerRequestMetadataRetryTestTransport(); + + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions(), + loggerFactory: LoggerFactory, cancellationToken: ct); + + Assert.Equal(2, transport.ServerDiscoverRequests); + Assert.False(transport.InitializeReceived); + Assert.Equal(McpProtocolVersions.July2026ProtocolVersion, client.NegotiatedProtocolVersion); + } + + [Fact] + public async Task Client_OnSilentProbe_FallsBackTo_Initialize_AfterConfiguredProbeTimeout() + { + // Simulate an initialize-handshake server that silently drops the unknown server/discover method (it never + // responds to the probe). The client must fall back to initialize once the configured + // DiscoverProbeTimeout elapses, well before the much larger InitializationTimeout. + var ct = TestContext.Current.CancellationToken; + await using var transport = new InitializeHandshakeServerTestTransport( + serverNegotiatedVersion: McpProtocolVersions.November2025ProtocolVersion, + silentDiscoverProbe: true); + + var stopwatch = Stopwatch.StartNew(); + // Default options (ProtocolVersion = null) prefer 2026-07-28 but allow automatic fallback. + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions + { + DiscoverProbeTimeout = TimeSpan.FromMilliseconds(250), + InitializationTimeout = TestConstants.DefaultTimeout, + }, loggerFactory: LoggerFactory, cancellationToken: ct); + stopwatch.Stop(); + + Assert.True(transport.ServerDiscoverProbed); + Assert.True(transport.InitializeReceived); + Assert.Equal(McpProtocolVersions.November2025ProtocolVersion, transport.InitializeProtocolVersion); + Assert.Equal(McpProtocolVersions.November2025ProtocolVersion, client.NegotiatedProtocolVersion); + + // The fallback was driven by the short probe timeout, not the 60s InitializationTimeout. + Assert.True( + stopwatch.Elapsed < TimeSpan.FromSeconds(30), + $"Fallback should have happened shortly after the {nameof(McpClientOptions.DiscoverProbeTimeout)}, but took {stopwatch.Elapsed}."); + } + + [Theory] + [InlineData(0)] + [InlineData(-1000)] + public void DiscoverProbeTimeout_Setter_Rejects_NonPositiveValues(int milliseconds) + { + var options = new McpClientOptions(); + Assert.Throws(() => options.DiscoverProbeTimeout = TimeSpan.FromMilliseconds(milliseconds)); + } + + [Fact] + public void DiscoverProbeTimeout_Setter_Accepts_PositiveAndInfiniteValues() + { + var options = new McpClientOptions(); + + // Default is the documented 5 seconds. + Assert.Equal(TimeSpan.FromSeconds(5), options.DiscoverProbeTimeout); + + options.DiscoverProbeTimeout = TimeSpan.FromSeconds(30); + Assert.Equal(TimeSpan.FromSeconds(30), options.DiscoverProbeTimeout); + + // Timeout.InfiniteTimeSpan disables the separate probe timeout (bounded by InitializationTimeout only). + options.DiscoverProbeTimeout = Timeout.InfiniteTimeSpan; + Assert.Equal(Timeout.InfiniteTimeSpan, options.DiscoverProbeTimeout); + } + + [Theory] + [InlineData(HttpStatusCode.NotFound, HttpTransportMode.StreamableHttp)] + [InlineData(HttpStatusCode.NotFound, HttpTransportMode.AutoDetect)] + [InlineData(HttpStatusCode.BadRequest, HttpTransportMode.StreamableHttp)] + [InlineData(HttpStatusCode.BadRequest, HttpTransportMode.AutoDetect)] + public async Task Client_OnFallbackHttpStatusFromProbe_FallsBackTo_Initialize( + HttpStatusCode status, HttpTransportMode transportMode) + { + // A server predating SEP-2575 can reject the session-less server/discover probe at the HTTP layer + // rather than with a JSON-RPC error: 404 when it requires Mcp-Session-Id on every non-initialize + // POST, or a plain/empty 400 when it cannot parse the request. Both are initialize-handshake + // servers, so the connect must fall back instead of failing. + var ct = TestContext.Current.CancellationToken; + var initializeReceived = false; + + using var mockHttpHandler = new MockHttpHandler(); + using var httpClient = new HttpClient(mockHttpHandler); + mockHttpHandler.RequestHandler = CreateProbeRejectingServer( + status, "Invalid session ID", () => initializeReceived = true); + + await using var transport = CreateTransport(httpClient, transportMode); + + // Default options (ProtocolVersion = null) prefer 2026-07-28 but allow automatic fallback. + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions(), + loggerFactory: LoggerFactory, cancellationToken: ct); + + Assert.True(initializeReceived); + Assert.Equal(McpProtocolVersions.November2025ProtocolVersion, client.NegotiatedProtocolVersion); + } + + [Theory] + [InlineData(HttpStatusCode.InternalServerError, HttpTransportMode.StreamableHttp)] + [InlineData(HttpStatusCode.Forbidden, HttpTransportMode.StreamableHttp)] + [InlineData(HttpStatusCode.InternalServerError, HttpTransportMode.AutoDetect)] + public async Task Client_OnOtherHttpErrorFromProbe_Surfaces_NoFallback( + HttpStatusCode status, HttpTransportMode transportMode) + { + // Only 400 and 404 are read as "this server needs the initialize handshake". Any other HTTP failure + // is a genuine transport error and must surface, so callers are not handed a misleading downstream + // error. Guards the deliberate narrowing of the status filter. + var ct = TestContext.Current.CancellationToken; + var initializeReceived = false; + + using var mockHttpHandler = new MockHttpHandler(); + using var httpClient = new HttpClient(mockHttpHandler); + mockHttpHandler.RequestHandler = CreateProbeRejectingServer( + status, "nope", () => initializeReceived = true); + + await using var transport = CreateTransport(httpClient, transportMode); + + await Assert.ThrowsAnyAsync(async () => + { + await using var client = await McpClient.CreateAsync(transport, new McpClientOptions(), + loggerFactory: LoggerFactory, cancellationToken: ct); + }); + + Assert.False(initializeReceived); + } + + private HttpClientTransport CreateTransport(HttpClient httpClient, HttpTransportMode transportMode) + => new(new HttpClientTransportOptions + { + Endpoint = new Uri("http://localhost"), + TransportMode = transportMode, + Name = "HTTP discover probe test client", + }, httpClient, LoggerFactory); + + /// + /// Mock Streamable HTTP server that rejects server/discover with + /// and, if the client falls back, completes an initialize handshake at 2025-11-25. + /// + private static Func> CreateProbeRejectingServer( + HttpStatusCode probeStatus, string probeBody, Action onInitialize) + => async request => + { + // The server offers no standalone SSE stream, which the spec permits. + // net472 does not populate a default Content, so every response sets one explicitly. + if (request.Method == HttpMethod.Get) + return EmptyResponse(HttpStatusCode.MethodNotAllowed); + + var body = await request.Content!.ReadAsStringAsync(); + using var doc = JsonDocument.Parse(body); + if (!doc.RootElement.TryGetProperty("method", out var methodElement)) + return EmptyResponse(HttpStatusCode.Accepted); + + switch (methodElement.GetString()) + { + case RequestMethods.ServerDiscover: + return new HttpResponseMessage(probeStatus) { Content = new StringContent(probeBody) }; + + case RequestMethods.Initialize: + onInitialize(); + var id = doc.RootElement.GetProperty("id").GetRawText(); + var result = "{\"jsonrpc\":\"2.0\",\"id\":" + id + + ",\"result\":{\"protocolVersion\":\"" + McpProtocolVersions.November2025ProtocolVersion + + "\",\"capabilities\":{},\"serverInfo\":{\"name\":\"test\",\"version\":\"1.0\"}}}"; + var response = new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new StringContent(result, Encoding.UTF8, "application/json"), + }; + response.Headers.Add("mcp-session-id", "test-session"); + return response; + + default: + return EmptyResponse(HttpStatusCode.Accepted); + } + }; + + private static HttpResponseMessage EmptyResponse(HttpStatusCode status) + => new(status) { Content = new StringContent(string.Empty) }; + + /// + /// Minimal in-memory transport that simulates an initialize-handshake server: rejects + /// server/discover (with a configurable JSON-RPC error code, or by + /// silently dropping the request) and responds to initialize with a + /// configurable protocol version. + /// + private sealed class InitializeHandshakeServerTestTransport( + string serverNegotiatedVersion, + int probeErrorCode = (int)McpErrorCode.MethodNotFound, + bool silentDiscoverProbe = false) : IClientTransport + { + private readonly Channel _incomingToClient = Channel.CreateUnbounded(); + + public string Name => "initialize-handshake-server-test-transport"; + + public bool ServerDiscoverProbed { get; private set; } + + public bool InitializeReceived { get; private set; } + + public string? InitializeProtocolVersion { get; private set; } + + public Task ConnectAsync(CancellationToken cancellationToken = default) + { + ITransport transport = new TransportChannel(_incomingToClient, this); + return Task.FromResult(transport); + } + + public ValueTask DisposeAsync() => default; + + private void HandleOutgoingMessage(JsonRpcMessage message) + { + switch (message) + { + case JsonRpcRequest { Method: RequestMethods.ServerDiscover } discoverReq: + ServerDiscoverProbed = true; + if (silentDiscoverProbe) + { + // Model an initialize-handshake server that drops the unknown method without replying. + break; + } + + _ = WriteAsync(new JsonRpcError + { + Id = discoverReq.Id, + Error = new JsonRpcErrorDetail + { + Code = probeErrorCode, + Message = probeErrorCode == (int)McpErrorCode.MethodNotFound + ? "Method not found" + : "Invalid params", + }, + }); + break; + + case JsonRpcRequest { Method: RequestMethods.Initialize } initReq: + InitializeReceived = true; + var initializeRequest = JsonSerializer.Deserialize(initReq.Params, McpJsonUtilities.DefaultOptions); + InitializeProtocolVersion = initializeRequest?.ProtocolVersion; + _ = WriteAsync(new JsonRpcResponse + { + Id = initReq.Id, + Result = JsonSerializer.SerializeToNode(new InitializeResult + { + ProtocolVersion = serverNegotiatedVersion, + Capabilities = new ServerCapabilities(), + ServerInfo = new Implementation { Name = "initialize-handshake-test-server", Version = "1.0.0" }, + }, McpJsonUtilities.DefaultOptions), + }); + break; + } + } + + private Task WriteAsync(JsonRpcMessage message) + => _incomingToClient.Writer.WriteAsync(message, CancellationToken.None).AsTask(); + + private sealed class TransportChannel( + Channel incoming, + InitializeHandshakeServerTestTransport parent) : ITransport + { + public ChannelReader MessageReader => incoming.Reader; + public bool IsConnected { get; private set; } = true; + public string? SessionId => null; + + public Task SendMessageAsync(JsonRpcMessage message, CancellationToken cancellationToken = default) + { + parent.HandleOutgoingMessage(message); + return Task.CompletedTask; + } + + public ValueTask DisposeAsync() + { + incoming.Writer.TryComplete(); + IsConnected = false; + return default; + } + } + } + + private sealed class PerRequestMetadataRetryTestTransport : IClientTransport + { + private readonly Channel _incomingToClient = Channel.CreateUnbounded(); + + public string Name => "per-request-metadata-retry-test-transport"; + + public int ServerDiscoverRequests { get; private set; } + + public bool InitializeReceived { get; private set; } + + public Task ConnectAsync(CancellationToken cancellationToken = default) + { + ITransport transport = new TransportChannel(_incomingToClient, this); + return Task.FromResult(transport); + } + + public ValueTask DisposeAsync() => default; + + private void HandleOutgoingMessage(JsonRpcMessage message) + { + switch (message) + { + case JsonRpcRequest { Method: RequestMethods.ServerDiscover } discoverReq: + ServerDiscoverRequests++; + + if (ServerDiscoverRequests == 1) + { + _ = WriteAsync(new JsonRpcError + { + Id = discoverReq.Id, + Error = new JsonRpcErrorDetail + { + Code = (int)McpErrorCode.UnsupportedProtocolVersion, + Message = "Unsupported protocol version", + Data = CreateUnsupportedProtocolVersionData(), + }, + }); + } + else + { + _ = WriteAsync(new JsonRpcResponse + { + Id = discoverReq.Id, + Result = JsonSerializer.SerializeToNode(new DiscoverResult + { + SupportedVersions = [McpProtocolVersions.July2026ProtocolVersion], + Capabilities = new ServerCapabilities(), + Meta = new JsonObject + { + [MetaKeys.ServerInfo] = JsonSerializer.SerializeToNode(new Implementation { Name = "per-request-metadata-test-server", Version = "1.0.0" }, McpJsonUtilities.DefaultOptions), + }, + }, McpJsonUtilities.DefaultOptions), + }); + } + + break; + + case JsonRpcRequest { Method: RequestMethods.Initialize }: + InitializeReceived = true; + break; + } + } + + private Task WriteAsync(JsonRpcMessage message) + => _incomingToClient.Writer.WriteAsync(message, CancellationToken.None).AsTask(); + + private static JsonElement CreateUnsupportedProtocolVersionData() + { + var json = JsonSerializer.Serialize(new UnsupportedProtocolVersionErrorData + { + Requested = McpProtocolVersions.July2026ProtocolVersion, + Supported = [McpProtocolVersions.July2026ProtocolVersion], + }, McpJsonUtilities.DefaultOptions); + + using var document = JsonDocument.Parse(json); + return document.RootElement.Clone(); + } + + private sealed class TransportChannel( + Channel incoming, + PerRequestMetadataRetryTestTransport parent) : ITransport + { + public ChannelReader MessageReader => incoming.Reader; + public bool IsConnected { get; private set; } = true; + public string? SessionId => null; + + public Task SendMessageAsync(JsonRpcMessage message, CancellationToken cancellationToken = default) + { + parent.HandleOutgoingMessage(message); + return Task.CompletedTask; + } + + public ValueTask DisposeAsync() + { + incoming.Writer.TryComplete(); + IsConnected = false; + return default; + } + } + } +} diff --git a/tests/ModelContextProtocol.Tests/Client/July2026ProtocolListMetaEmissionTests.cs b/tests/ModelContextProtocol.Tests/Client/July2026ProtocolListMetaEmissionTests.cs new file mode 100644 index 000000000..dd7ba7b29 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Client/July2026ProtocolListMetaEmissionTests.cs @@ -0,0 +1,180 @@ +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.Text.Json; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.Tests.Client; + +/// +/// Verifies that the C# client emits the SEP-2575 _meta envelope on every list-style +/// request (and on server/discover) under the 2026-07-28 protocol revision, even when +/// the caller supplies no RequestOptions / no params. +/// +/// +/// Spec PR #2759 promotes params._meta to required on tools/list, +/// resources/list, resources/templates/list, prompts/list, and +/// server/discover. This test class drives the C# client through +/// with the 2026-07-28 protocol negotiated, attaches a request +/// filter on each list endpoint that captures the incoming _meta envelope, and asserts +/// the three required SEP-2575 keys are present: +/// io.modelcontextprotocol/protocolVersion, +/// io.modelcontextprotocol/clientInfo, and +/// io.modelcontextprotocol/clientCapabilities. +/// +public class July2026ProtocolListMetaEmissionTests : ClientServerTestBase +{ + private const string LatestStableVersion = "2025-11-25"; + + // Captured _meta envelopes for each request method we exercise. Populated by the per-method + // server-side filters and asserted from each test method. + private readonly Dictionary _capturedMeta = new(StringComparer.Ordinal); + + public July2026ProtocolListMetaEmissionTests(ITestOutputHelper testOutputHelper) + : base(testOutputHelper, startServer: false) + { + } + + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + mcpServerBuilder.WithRequestFilters(filters => + { + filters.AddListToolsFilter(next => async (request, cancellationToken) => + { + _capturedMeta[RequestMethods.ToolsList] = request.Params?.Meta; + return await next(request, cancellationToken); + }); + filters.AddListPromptsFilter(next => async (request, cancellationToken) => + { + _capturedMeta[RequestMethods.PromptsList] = request.Params?.Meta; + return await next(request, cancellationToken); + }); + filters.AddListResourcesFilter(next => async (request, cancellationToken) => + { + _capturedMeta[RequestMethods.ResourcesList] = request.Params?.Meta; + return await next(request, cancellationToken); + }); + filters.AddListResourceTemplatesFilter(next => async (request, cancellationToken) => + { + _capturedMeta[RequestMethods.ResourcesTemplatesList] = request.Params?.Meta; + return await next(request, cancellationToken); + }); + }); + + // No-op list handlers (so the requests complete) — content is irrelevant; we only assert the + // incoming envelope. + mcpServerBuilder + .WithListToolsHandler((_, _) => new ValueTask(new ListToolsResult { Tools = [] })) + .WithListPromptsHandler((_, _) => new ValueTask(new ListPromptsResult { Prompts = [] })) + .WithListResourcesHandler((_, _) => new ValueTask(new ListResourcesResult { Resources = [] })) + .WithListResourceTemplatesHandler((_, _) => new ValueTask( + new ListResourceTemplatesResult { ResourceTemplates = [] })); + } + + [Fact] + public async Task Client_ListTools_NoOptions_EmitsRequiredMeta() + { + StartServer(); + await using var client = await CreateMcpClientForServer(new McpClientOptions { ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion }); + + await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + AssertRequiredMetaPresent(RequestMethods.ToolsList); + } + + [Fact] + public async Task Client_ListPrompts_NoOptions_EmitsRequiredMeta() + { + StartServer(); + await using var client = await CreateMcpClientForServer(new McpClientOptions { ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion }); + + await client.ListPromptsAsync(cancellationToken: TestContext.Current.CancellationToken); + + AssertRequiredMetaPresent(RequestMethods.PromptsList); + } + + [Fact] + public async Task Client_ListResources_NoOptions_EmitsRequiredMeta() + { + StartServer(); + await using var client = await CreateMcpClientForServer(new McpClientOptions { ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion }); + + await client.ListResourcesAsync(cancellationToken: TestContext.Current.CancellationToken); + + AssertRequiredMetaPresent(RequestMethods.ResourcesList); + } + + [Fact] + public async Task Client_ListResourceTemplates_NoOptions_EmitsRequiredMeta() + { + StartServer(); + await using var client = await CreateMcpClientForServer(new McpClientOptions { ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion }); + + await client.ListResourceTemplatesAsync(cancellationToken: TestContext.Current.CancellationToken); + + AssertRequiredMetaPresent(RequestMethods.ResourcesTemplatesList); + } + + [Fact] + public async Task Client_ServerDiscover_EmitsRequiredMeta() + { + // server/discover has no public List-style helper; we drive it via SendRequestAsync directly, + // which still flows through the client's per-request _meta injector. + StartServer(); + await using var client = await CreateMcpClientForServer(new McpClientOptions { ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion }); + + // Hook the server-side handler invocation via a notification handler is awkward here; assert + // instead by sending the request and parsing the wire-shape echo from the response context. + // Easier path: rely on the existing JsonRpcRequest capture in the message context (see the + // raw conformance tests for the wire-level proof). For this in-process test, we instead drive + // the request and rely on the response being a valid DiscoverResult; the _meta injector + // would otherwise have failed the server's per-request envelope validation. + var response = await client.SendRequestAsync( + new JsonRpcRequest { Method = RequestMethods.ServerDiscover }, + TestContext.Current.CancellationToken); + + Assert.NotNull(response.Result); + var discover = JsonSerializer.Deserialize(response.Result, McpJsonUtilities.DefaultOptions)!; + Assert.Contains(McpProtocolVersions.July2026ProtocolVersion, discover.SupportedVersions); + + // The server enforces the per-request envelope shape; if the client had omitted _meta, the + // request would have failed with -32602 / -32021 rather than returning a DiscoverResult. The + // successful round-trip is the assertion. + } + + [Fact] + public async Task InitializeHandshakeClient_ListTools_DoesNotEmitMeta() + { + // Sanity guard: a client on the session-supporting initialize-handshake protocol must NOT emit the SEP-2575 + // envelope. The injector is gated on the negotiated protocol version; if it ever started writing + // those keys on an initialize-handshake request, every initialize-handshake server would reject it. + StartServer(); + await using var client = await CreateMcpClientForServer(new McpClientOptions { ProtocolVersion = LatestStableVersion }); + + await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + var meta = _capturedMeta[RequestMethods.ToolsList]; + if (meta is not null) + { + Assert.False(meta.ContainsKey(MetaKeys.ProtocolVersion)); + Assert.False(meta.ContainsKey(MetaKeys.ClientInfo)); + Assert.False(meta.ContainsKey(MetaKeys.ClientCapabilities)); + } + } + + private void AssertRequiredMetaPresent(string method) + { + Assert.True(_capturedMeta.TryGetValue(method, out var meta), $"No capture for {method}"); + Assert.NotNull(meta); + Assert.True(meta!.ContainsKey(MetaKeys.ProtocolVersion), + $"Missing protocolVersion key on {method} _meta envelope"); + Assert.True(meta.ContainsKey(MetaKeys.ClientInfo), + $"Missing clientInfo key on {method} _meta envelope"); + Assert.True(meta.ContainsKey(MetaKeys.ClientCapabilities), + $"Missing clientCapabilities key on {method} _meta envelope"); + + // The protocolVersion value must match the negotiated 2026-07-28 protocol version. + Assert.Equal(McpProtocolVersions.July2026ProtocolVersion, meta[MetaKeys.ProtocolVersion]!.GetValue()); + } +} diff --git a/tests/ModelContextProtocol.Tests/Client/McpClientAddKnownToolsTests.cs b/tests/ModelContextProtocol.Tests/Client/McpClientAddKnownToolsTests.cs new file mode 100644 index 000000000..16d9c3397 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Client/McpClientAddKnownToolsTests.cs @@ -0,0 +1,430 @@ +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.Text.Json; + +namespace ModelContextProtocol.Tests.Client; + +public class McpClientAddKnownToolsTests : ClientServerTestBase +{ + private const string ServerToolName = "ServerTool"; + private const string ServerToolName2 = "ServerTool2"; + + public McpClientAddKnownToolsTests(ITestOutputHelper outputHelper) + : base(outputHelper) + { + } + + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + mcpServerBuilder.WithTools([ + McpServerTool.Create( + (string input) => $"echo {input}", + new() { Name = ServerToolName }), + McpServerTool.Create( + (string input) => $"echo2 {input}", + new() { Name = ServerToolName2 }), + ]); + } + + private static Tool CreateTool(string name, string? headerAnnotation = null) + { + string schemaJson = headerAnnotation is not null + ? $$""" + { + "type": "object", + "properties": { + "param1": { + "type": "string", + "x-mcp-header": "{{headerAnnotation}}" + } + } + } + """ + : """ + { + "type": "object", + "properties": { + "param1": { + "type": "string" + } + } + } + """; + + return new Tool + { + Name = name, + InputSchema = JsonDocument.Parse(schemaJson).RootElement.Clone(), + }; + } + + private static Tool CreateInvalidTool(string name) + { + // Colon in header name is invalid + var schemaJson = """ + { + "type": "object", + "properties": { + "param1": { + "type": "string", + "x-mcp-header": "Invalid:Header" + } + } + } + """; + + return new Tool + { + Name = name, + InputSchema = JsonDocument.Parse(schemaJson).RootElement.Clone(), + }; + } + + [Fact] + public async Task AddKnownTools_ThenListToolsAsync_ServerToolsStillReturned() + { + // Arrange + await using var client = await CreateMcpClientForServer(); + var registeredTool = CreateTool("MyRegisteredTool", "X-Custom"); + + // Act — register without calling ListToolsAsync first, then list + client.AddKnownTools([registeredTool]); + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + // Assert — ListToolsAsync returns server tools (registered tools stay in cache for header generation + // but are not returned by ListToolsAsync which only returns server-reported tools) + Assert.Contains(tools, t => t.Name == ServerToolName); + Assert.Contains(tools, t => t.Name == ServerToolName2); + Assert.Equal(2, tools.Count); + } + + [Fact] + public async Task AddKnownTools_ThenMultipleListToolsAsync_ServerToolsAlwaysRepopulated() + { + // Arrange + await using var client = await CreateMcpClientForServer(); + client.AddKnownTools([CreateTool("MyRegisteredTool", "X-Custom")]); + + // Act — ListToolsAsync clears non-registered tools and repopulates from server + var tools1 = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + var tools2 = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + // Assert — server tools repopulated correctly after each clear + Assert.Contains(tools1, t => t.Name == ServerToolName); + Assert.Contains(tools1, t => t.Name == ServerToolName2); + Assert.Contains(tools2, t => t.Name == ServerToolName); + Assert.Contains(tools2, t => t.Name == ServerToolName2); + } + + [Fact] + public async Task ListToolsAsync_ThenRegisterTool_ServerToolsStillRepopulated() + { + // Arrange + await using var client = await CreateMcpClientForServer(); + + // Act — list first, then register, then list again + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + Assert.Equal(2, tools.Count); + + client.AddKnownTools([CreateTool("MyRegisteredTool", "X-Custom")]); + + var tools2 = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + // Assert — server tools still repopulated after registering + Assert.Contains(tools2, t => t.Name == ServerToolName); + Assert.Contains(tools2, t => t.Name == ServerToolName2); + } + + [Fact] + public async Task RegisterTool_ListToolsAsync_RegisterTool_ServerToolsIntact() + { + // Arrange + await using var client = await CreateMcpClientForServer(); + + // Act — register, list, register again + client.AddKnownTools([CreateTool("FirstRegistered", "X-First")]); + await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + client.AddKnownTools([CreateTool("SecondRegistered", "X-Second")]); + + // Another ListToolsAsync — server tools should still be repopulated + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + Assert.Contains(tools, t => t.Name == ServerToolName); + Assert.Contains(tools, t => t.Name == ServerToolName2); + } + + [Fact] + public async Task AddKnownTools_WithSameNameAsServerTool_ServerDefinitionReturned() + { + // Arrange + await using var client = await CreateMcpClientForServer(); + var registeredTool = CreateTool(ServerToolName, "X-Override"); + + // Act — register a tool with the same name as a server tool, then list + client.AddKnownTools([registeredTool]); + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + // Assert — server's definition is returned by ListToolsAsync + Assert.Contains(tools, t => t.Name == ServerToolName); + + // After another ListToolsAsync, the tool is still present (pinned as registered + server tool) + var tools2 = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + Assert.Contains(tools2, t => t.Name == ServerToolName); + } + + [Fact] + public async Task AddKnownTools_WithInvalidSchema_ThrowsArgumentException() + { + // Arrange + await using var client = await CreateMcpClientForServer(); + var invalidTool = CreateInvalidTool("BadTool"); + var validTool = CreateTool("GoodTool", "X-Good"); + + // Act & Assert — all-or-nothing: neither tool should be added + var ex = Assert.Throws(() => client.AddKnownTools([invalidTool, validTool])); + Assert.Contains("BadTool", ex.Message); + + // Server tools still work normally + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + Assert.Contains(tools, t => t.Name == ServerToolName); + Assert.Contains(tools, t => t.Name == ServerToolName2); + } + + [Fact] + public async Task AddKnownTools_DuplicateRegistration_DoesNotBreakCache() + { + // Arrange + await using var client = await CreateMcpClientForServer(); + var tool1 = CreateTool("MyTool", "X-First"); + var tool2 = CreateTool("MyTool", "X-Second"); + + // Act — register same name twice; second should overwrite + client.AddKnownTools([tool1]); + client.AddKnownTools([tool2]); + + // Assert — cache clearing still works; server tools repopulated + await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + Assert.Contains(tools, t => t.Name == ServerToolName); + Assert.Contains(tools, t => t.Name == ServerToolName2); + } + + [Fact] + public async Task AddKnownTools_NullArgument_ThrowsArgumentNullException() + { + await using var client = await CreateMcpClientForServer(); + Assert.Throws(() => client.AddKnownTools(null!)); + } + + [Fact] + public async Task MultipleListToolsAsync_WithRegisteredTools_ServerToolsAlwaysRepopulated() + { + // Arrange + await using var client = await CreateMcpClientForServer(); + client.AddKnownTools([CreateTool("PinnedTool", "X-Pinned")]); + + // Act — call ListToolsAsync multiple times + await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + // Assert — server tools repopulated each time despite registered tool in cache + Assert.Contains(tools, t => t.Name == ServerToolName); + Assert.Contains(tools, t => t.Name == ServerToolName2); + } + + [Fact] + public async Task AddKnownTools_WithNoHeaderAnnotation_StillAccepted() + { + // Arrange — a tool without x-mcp-header is still valid and should be cached + await using var client = await CreateMcpClientForServer(); + var tool = CreateTool("PlainTool"); + + // Act — register a tool with no x-mcp-header; should not throw + client.AddKnownTools([tool]); + + // Assert — server tools still repopulated after cache clears + await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + Assert.Contains(tools, t => t.Name == ServerToolName); + Assert.Contains(tools, t => t.Name == ServerToolName2); + } + + [Fact] + public async Task AddKnownTools_ThenCallTool_RegisteredToolUsedForCacheLookup() + { + // Arrange — register a tool with the same name as a server tool so CallToolAsync succeeds server-side + await using var client = await CreateMcpClientForServer(); + var tool = CreateTool(ServerToolName, "X-Custom"); + + // Act — register without ListToolsAsync, then call the tool directly + client.AddKnownTools([tool]); + + // The tool is in the cache, so SendRequestAsync will find it for header attachment. + // The server has a tool with this name, so the call succeeds. + var result = await client.CallToolAsync( + ServerToolName, + new Dictionary { ["input"] = "test" }, + cancellationToken: TestContext.Current.CancellationToken); + + // Assert — call succeeded (tool was found in cache, request was processed by server) + Assert.NotNull(result); + Assert.Contains(result.Content, c => c is TextContentBlock text && text.Text == "echo test"); + } + + [Fact] + public async Task RemoveKnownTools_RemovedToolNoLongerSurvivesListToolsAsync() + { + // Arrange + await using var client = await CreateMcpClientForServer(); + client.AddKnownTools([CreateTool("MyTool", "X-Custom")]); + + // Act — remove the known tool + client.RemoveKnownTools(["MyTool"]); + + // Assert — server tools still repopulated, removed tool doesn't interfere + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + Assert.Contains(tools, t => t.Name == ServerToolName); + Assert.Contains(tools, t => t.Name == ServerToolName2); + } + + [Fact] + public async Task RemoveKnownTools_NonExistentName_IsNoOp() + { + await using var client = await CreateMcpClientForServer(); + + // Should not throw + client.RemoveKnownTools(["NonExistentTool"]); + + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + Assert.Contains(tools, t => t.Name == ServerToolName); + } + + [Fact] + public async Task RemoveKnownTools_NullArgument_ThrowsArgumentNullException() + { + await using var client = await CreateMcpClientForServer(); + Assert.Throws(() => client.RemoveKnownTools(null!)); + } + + [Fact] + public async Task RemoveKnownTools_PartialRemove_OtherToolsSurvive() + { + // Arrange + await using var client = await CreateMcpClientForServer(); + client.AddKnownTools([ + CreateTool("ToolA", "X-A"), + CreateTool("ToolB", "X-B"), + ]); + + // Act — remove only ToolA + client.RemoveKnownTools(["ToolA"]); + + // Assert — ToolB still survives cache clears, server tools repopulated + await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + Assert.Contains(tools, t => t.Name == ServerToolName); + Assert.Contains(tools, t => t.Name == ServerToolName2); + } + + [Fact] + public async Task ClearKnownTools_RemovesAllKnownToolsFromCache() + { + // Arrange + await using var client = await CreateMcpClientForServer(); + client.AddKnownTools([ + CreateTool("ToolA", "X-A"), + CreateTool("ToolB", "X-B"), + ]); + + // Act + client.ClearKnownTools(); + + // Assert — server tools still work after clearing known tools + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + Assert.Contains(tools, t => t.Name == ServerToolName); + Assert.Contains(tools, t => t.Name == ServerToolName2); + } + + [Fact] + public async Task ClearKnownTools_WhenEmpty_IsNoOp() + { + await using var client = await CreateMcpClientForServer(); + + // Should not throw when nothing is registered + client.ClearKnownTools(); + + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + Assert.Contains(tools, t => t.Name == ServerToolName); + } + + [Fact] + public async Task ClearKnownTools_ThenAddKnownTools_WorksCorrectly() + { + // Arrange + await using var client = await CreateMcpClientForServer(); + client.AddKnownTools([CreateTool("ToolA", "X-A")]); + + // Act — clear then add new tools + client.ClearKnownTools(); + client.AddKnownTools([CreateTool("ToolC", "X-C")]); + + // Assert — server tools repopulated, new tool doesn't interfere + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + Assert.Contains(tools, t => t.Name == ServerToolName); + } + + [Fact] + public async Task AddKnownTools_PartialFailure_NothingRegistered() + { + // Arrange — [valid, invalid, valid] should register nothing (all-or-nothing) + await using var client = await CreateMcpClientForServer(); + var valid1 = CreateTool("Valid1", "X-One"); + var invalid = CreateInvalidTool("BadTool"); + var valid2 = CreateTool("Valid2", "X-Two"); + + // Act & Assert — throws, no tools registered + Assert.Throws(() => client.AddKnownTools([valid1, invalid, valid2])); + + // Server tools still work; none of the valid tools were cached + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + Assert.Contains(tools, t => t.Name == ServerToolName); + Assert.Equal(2, tools.Count); + } + + [Fact] + public async Task AddKnownTools_NullElementInMiddle_NothingRegistered() + { + // Arrange — null element at index 1; elements before it should not be cached + await using var client = await CreateMcpClientForServer(); + var valid = CreateTool("Valid", "X-Valid"); + + // Act & Assert — throws ArgumentNullException on null element, nothing cached + Assert.Throws(() => client.AddKnownTools([valid, null!, CreateTool("Other", "X-Other")])); + + // Server tools still work; valid tool was NOT cached due to atomicity + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + Assert.Equal(2, tools.Count); + } + + [Fact] + public async Task CallToolWithoutCache_PipeTransport_DoesNotLogWarning() + { + // Arrange — pipe transport should NOT log a cache miss warning + await using var client = await CreateMcpClientForServer(); + + // Act — call a server tool without populating cache via ListToolsAsync + var result = await client.CallToolAsync( + ServerToolName, + new Dictionary { ["input"] = "test" }, + cancellationToken: TestContext.Current.CancellationToken); + + // Assert — call succeeds and no cache miss warning is logged (pipe transport, not HTTP) + Assert.NotNull(result); + Assert.DoesNotContain(MockLoggerProvider.LogMessages, log => + log.LogLevel == Microsoft.Extensions.Logging.LogLevel.Warning && + log.Message.Contains("not found in cache during tools/call")); + } +} diff --git a/tests/ModelContextProtocol.Tests/Client/McpClientCreationTests.cs b/tests/ModelContextProtocol.Tests/Client/McpClientCreationTests.cs index b2935d247..c6f8016dd 100644 --- a/tests/ModelContextProtocol.Tests/Client/McpClientCreationTests.cs +++ b/tests/ModelContextProtocol.Tests/Client/McpClientCreationTests.cs @@ -4,6 +4,7 @@ using ModelContextProtocol.Tests.Utils; using System.IO.Pipelines; using System.Text.Json; +using System.Text.Json.Nodes; using System.Threading.Channels; namespace ModelContextProtocol.Tests.Client; @@ -171,10 +172,30 @@ public virtual Task SendMessageAsync(JsonRpcMessage message, CancellationToken c { switch (message) { - case JsonRpcRequest: + case JsonRpcRequest { Method: RequestMethods.ServerDiscover } discoverRequest: _channel.Writer.TryWrite(new JsonRpcResponse { - Id = ((JsonRpcRequest)message).Id, + Id = discoverRequest.Id, + Result = JsonSerializer.SerializeToNode(new DiscoverResult + { + Capabilities = new ServerCapabilities(), + SupportedVersions = [McpProtocolVersions.July2026ProtocolVersion], + Meta = new JsonObject + { + [MetaKeys.ServerInfo] = JsonSerializer.SerializeToNode(new Implementation + { + Name = "NopTransport", + Version = "1.0.0" + }, McpJsonUtilities.DefaultOptions), + }, + }, McpJsonUtilities.DefaultOptions), + }); + break; + + case JsonRpcRequest request: + _channel.Writer.TryWrite(new JsonRpcResponse + { + Id = request.Id, Result = JsonSerializer.SerializeToNode(new InitializeResult { Capabilities = new ServerCapabilities(), diff --git a/tests/ModelContextProtocol.Tests/Client/McpClientMetaTests.cs b/tests/ModelContextProtocol.Tests/Client/McpClientMetaTests.cs index 863d8e671..3afbb52eb 100644 --- a/tests/ModelContextProtocol.Tests/Client/McpClientMetaTests.cs +++ b/tests/ModelContextProtocol.Tests/Client/McpClientMetaTests.cs @@ -2,12 +2,23 @@ using ModelContextProtocol.Client; using ModelContextProtocol.Protocol; using ModelContextProtocol.Server; +using ModelContextProtocol.Tests.Utils; +using System.Text.Json; using System.Text.Json.Nodes; namespace ModelContextProtocol.Tests.Client; public class McpClientMetaTests : ClientServerTestBase { + // InitializeMeta is carried on the legacy initialize request, which the 2026-07-28 protocol removes. + // The two InitializeMeta_* tests pin to the latest stable version so the handshake actually runs. + private const string LatestStableVersion = "2025-11-25"; + + private readonly TaskCompletionSource _initializeMeta = new(); + + private readonly TaskCompletionSource<(Implementation? Info, ClientCapabilities? Capabilities)> _outgoingFilterObserved = + new(TaskCreationOptions.RunContinuationsAsynchronously); + public McpClientMetaTests(ITestOutputHelper outputHelper) : base(outputHelper) { @@ -28,6 +39,66 @@ protected override void ConfigureServices(ServiceCollection services, IMcpServer o.ResourceCollection = new (); o.PromptCollection = new (); }); + + // Capture the _meta the server receives on the initialize request so tests can + // assert that McpClientOptions.InitializeMeta is threaded through the handshake. + mcpServerBuilder.WithMessageFilters(filters => + { + filters.AddIncomingFilter(next => async (context, cancellationToken) => + { + if (context.JsonRpcMessage is JsonRpcRequest { Method: RequestMethods.Initialize } request) + { + _initializeMeta.TrySetResult(request.Params?["_meta"]); + } + + await next(context, cancellationToken); + }); + + // Capture the request-scoped client info/capabilities observed while an outgoing response flows + // through the outgoing filter pipeline. Gated on a unique client name so only the dedicated test + // triggers it. This exercises that DestinationBoundMcpServer resolves per-request _meta for + // responses (whose Context is the originating request's Context), not just requests. + filters.AddOutgoingFilter(next => async (context, cancellationToken) => + { + if (context.JsonRpcMessage is JsonRpcResponse && + context.Server.ClientInfo is { Name: "outgoing-filter-client" } info) + { + _outgoingFilterObserved.TrySetResult((info, context.Server.ClientCapabilities)); + } + + await next(context, cancellationToken); + }); + }); + } + + [Fact] + public async Task InitializeMeta_IsSentToServer_WhenSet() + { + var clientOptions = new McpClientOptions + { + ProtocolVersion = LatestStableVersion, + InitializeMeta = new JsonObject + { + { "foo", "bar baz" } + } + }; + + await using McpClient client = await CreateMcpClientForServer(clientOptions); + + var meta = await _initializeMeta.Task.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); + + Assert.NotNull(meta); + Assert.Equal("bar baz", meta["foo"]?.ToString()); + } + + [Fact] + public async Task InitializeMeta_IsOmitted_WhenNotSet() + { + await using McpClient client = await CreateMcpClientForServer(new McpClientOptions { ProtocolVersion = LatestStableVersion }); + + var meta = await _initializeMeta.Task.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); + + Assert.Null(meta); } [Fact] @@ -66,6 +137,177 @@ public async Task ToolCallWithMetaFields() Assert.Contains("bar baz", textContent.Text); } + [Fact] + public async Task ConcurrentToolCalls_WithPerRequestClientCapabilities_UseRequestScopedCapabilities() + { + var withSamplingReady = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + var withoutSamplingReady = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + var allowSamplingChecks = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + + Server.ServerOptions.ToolCollection?.Add(McpServerTool.Create( + async (string requestId, RequestContext context, CancellationToken cancellationToken) => + { + if (requestId == "with") + { + withSamplingReady.TrySetResult(true); + } + else if (requestId == "without") + { + withoutSamplingReady.TrySetResult(true); + } + else + { + throw new ArgumentException($"Unexpected request id '{requestId}'."); + } + + await allowSamplingChecks.Task.WaitAsync(TestConstants.DefaultTimeout, cancellationToken); + + return context.Server.ClientCapabilities?.Sampling is null ? + $"{requestId}:sampling-absent" : + $"{requestId}:sampling-present"; + }, + new() { Name = "meta_sampling_tool" })); + + await using McpClient client = await CreateMcpClientForServer(); + + var withSamplingRequest = new CallToolRequestParams + { + Name = "meta_sampling_tool", + Arguments = new Dictionary + { + ["requestId"] = JsonDocument.Parse("\"with\"").RootElement.Clone(), + }, + Meta = new JsonObject + { + [MetaKeys.ClientCapabilities] = JsonSerializer.SerializeToNode( + new ClientCapabilities { Sampling = new SamplingCapability() }, + McpJsonUtilities.DefaultOptions), + }, + }; + + var withoutSamplingRequest = new CallToolRequestParams + { + Name = "meta_sampling_tool", + Arguments = new Dictionary + { + ["requestId"] = JsonDocument.Parse("\"without\"").RootElement.Clone(), + }, + Meta = new JsonObject + { + [MetaKeys.ClientCapabilities] = JsonSerializer.SerializeToNode( + new ClientCapabilities(), + McpJsonUtilities.DefaultOptions), + }, + }; + + Task withSamplingTask = client.CallToolAsync(withSamplingRequest, TestContext.Current.CancellationToken).AsTask(); + Task withoutSamplingTask = client.CallToolAsync(withoutSamplingRequest, TestContext.Current.CancellationToken).AsTask(); + + await Task.WhenAll(withSamplingReady.Task, withoutSamplingReady.Task).WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); + allowSamplingChecks.TrySetResult(true); + + CallToolResult withSamplingResult = await withSamplingTask; + CallToolResult withoutSamplingResult = await withoutSamplingTask; + + var withSamplingText = Assert.IsType(Assert.Single(withSamplingResult.Content)).Text; + var withoutSamplingText = Assert.IsType(Assert.Single(withoutSamplingResult.Content)).Text; + + Assert.Equal("with:sampling-present", withSamplingText); + Assert.Equal("without:sampling-absent", withoutSamplingText); + } + + [Fact] + public async Task ToolCall_UnderJuly2026Protocol_ObservesRequestScopedClientInfo() + { + Server.ServerOptions.ToolCollection?.Add(McpServerTool.Create( + (RequestContext context) => + { + var clientInfo = context.Server.ClientInfo; + return clientInfo is null ? + "client-info-absent" : + $"{clientInfo.Name}:{clientInfo.Version}"; + }, + new() { Name = "client_info_tool" })); + + // The 2026-07-28+ client stamps its ClientInfo onto every request's _meta, so the tool must observe + // the per-request value resolved by DestinationBoundMcpServer rather than server-only session state. + var clientOptions = new McpClientOptions + { + ClientInfo = new Implementation { Name = "request-scoped-client", Version = "9.9.9" }, + }; + + await using McpClient client = await CreateMcpClientForServer(clientOptions); + + var result = await client.CallToolAsync("client_info_tool", cancellationToken: TestContext.Current.CancellationToken); + + var text = Assert.IsType(Assert.Single(result.Content)).Text; + Assert.Equal("request-scoped-client:9.9.9", text); + } + + [Fact] + public async Task RootServer_UnderJuly2026Protocol_HasNoClientCapabilities_ButHandlerObservesThem() + { + ClientCapabilities? handlerObservedCapabilities = null; + + Server.ServerOptions.ToolCollection?.Add(McpServerTool.Create( + (RequestContext context) => + { + handlerObservedCapabilities = context.Server.ClientCapabilities; + return "ok"; + }, + new() { Name = "capability_probe_tool" })); + + var clientOptions = new McpClientOptions + { + Handlers = new McpClientHandlers + { + ElicitationHandler = (_, _) => new ValueTask(new ElicitResult()), + }, + }; + + await using McpClient client = await CreateMcpClientForServer(clientOptions); + + // Under the 2026-07-28 revision capabilities are request-scoped, so the root server (outside any + // request) never exposes them, whereas a request handler observes the per-request _meta values. + Assert.Null(Server.ClientCapabilities); + + await client.CallToolAsync("capability_probe_tool", cancellationToken: TestContext.Current.CancellationToken); + + Assert.NotNull(handlerObservedCapabilities); + Assert.NotNull(handlerObservedCapabilities!.Elicitation); + Assert.Null(Server.ClientCapabilities); + } + + [Fact] + public async Task OutgoingMessageFilter_UnderJuly2026Protocol_ObservesRequestScopedClientInfoAndCapabilities() + { + Server.ServerOptions.ToolCollection?.Add(McpServerTool.Create( + () => "ok", + new() { Name = "outgoing_probe_tool" })); + + var clientOptions = new McpClientOptions + { + ClientInfo = new Implementation { Name = "outgoing-filter-client", Version = "3.2.1" }, + Handlers = new McpClientHandlers + { + ElicitationHandler = (_, _) => new ValueTask(new ElicitResult()), + }, + }; + + await using McpClient client = await CreateMcpClientForServer(clientOptions); + + await client.CallToolAsync("outgoing_probe_tool", cancellationToken: TestContext.Current.CancellationToken); + + var (info, capabilities) = await _outgoingFilterObserved.Task + .WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); + + Assert.NotNull(info); + Assert.Equal("outgoing-filter-client", info!.Name); + Assert.Equal("3.2.1", info.Version); + Assert.NotNull(capabilities); + Assert.NotNull(capabilities!.Elicitation); + } + [Fact] public async Task ResourceReadWithMetaFields() { diff --git a/tests/ModelContextProtocol.Tests/Client/McpClientResourceSubscriptionTests.cs b/tests/ModelContextProtocol.Tests/Client/McpClientResourceSubscriptionTests.cs index 2ee3cec26..82a3bd9c2 100644 --- a/tests/ModelContextProtocol.Tests/Client/McpClientResourceSubscriptionTests.cs +++ b/tests/ModelContextProtocol.Tests/Client/McpClientResourceSubscriptionTests.cs @@ -19,6 +19,12 @@ protected override void ConfigureServices(ServiceCollection services, IMcpServer mcpServerBuilder.WithResources(); } + private Task CreateLegacyMcpClientForServer() => + CreateMcpClientForServer(new() + { + ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion, + }); + [McpServerResourceType] private sealed class SubscribableResources { @@ -30,7 +36,7 @@ private sealed class SubscribableResources public async Task SubscribeToResourceAsync_WithHandler_ReceivesNotifications() { // Arrange - await using McpClient client = await CreateMcpClientForServer(); + await using McpClient client = await CreateLegacyMcpClientForServer(); const string resourceUri = "test://resource/1"; var notificationReceived = new TaskCompletionSource(); @@ -61,7 +67,7 @@ await Server.SendNotificationAsync( public async Task SubscribeToResourceAsync_WithHandler_FiltersNotificationsByUri() { // Arrange - await using McpClient client = await CreateMcpClientForServer(); + await using McpClient client = await CreateLegacyMcpClientForServer(); const string subscribedUri = "test://resource/1"; const string otherUri = "test://resource/2"; var notificationCount = 0; @@ -107,7 +113,7 @@ await Server.SendNotificationAsync( public async Task SubscribeToResourceAsync_WithHandler_DisposalUnsubscribes() { // Arrange - await using McpClient client = await CreateMcpClientForServer(); + await using McpClient client = await CreateLegacyMcpClientForServer(); const string resourceUri = "test://resource/1"; var notificationCount = 0; @@ -148,7 +154,7 @@ await Server.SendNotificationAsync( public async Task SubscribeToResourceAsync_WithHandler_UriOverload_ReceivesNotifications() { // Arrange - await using McpClient client = await CreateMcpClientForServer(); + await using McpClient client = await CreateLegacyMcpClientForServer(); var resourceUri = new Uri("test://resource/1"); var notificationReceived = new TaskCompletionSource(); @@ -179,7 +185,7 @@ await Server.SendNotificationAsync( public async Task SubscribeToResourceAsync_WithNullHandler_ThrowsArgumentNullException() { // Arrange - await using McpClient client = await CreateMcpClientForServer(); + await using McpClient client = await CreateLegacyMcpClientForServer(); // Act & Assert await Assert.ThrowsAsync(async () => @@ -193,7 +199,7 @@ await client.SubscribeToResourceAsync( public async Task SubscribeToResourceAsync_WithNullUri_ThrowsArgumentNullException() { // Arrange - await using McpClient client = await CreateMcpClientForServer(); + await using McpClient client = await CreateLegacyMcpClientForServer(); // Act & Assert await Assert.ThrowsAsync(async () => @@ -207,7 +213,7 @@ await client.SubscribeToResourceAsync( public async Task SubscribeToResourceAsync_WithEmptyUri_ThrowsArgumentException() { // Arrange - await using McpClient client = await CreateMcpClientForServer(); + await using McpClient client = await CreateLegacyMcpClientForServer(); // Act & Assert await Assert.ThrowsAsync(async () => @@ -221,7 +227,7 @@ await client.SubscribeToResourceAsync( public async Task SubscribeToResourceAsync_MultipleSubscriptions_BothReceiveNotifications() { // Arrange - await using McpClient client = await CreateMcpClientForServer(); + await using McpClient client = await CreateLegacyMcpClientForServer(); const string uri1 = "test://resource/1"; const string uri2 = "test://resource/2"; var notification1Received = new TaskCompletionSource(); @@ -278,7 +284,7 @@ await Task.WhenAll( public async Task SubscribeToResourceAsync_DisposalIsIdempotent() { // Arrange - await using McpClient client = await CreateMcpClientForServer(); + await using McpClient client = await CreateLegacyMcpClientForServer(); const string resourceUri = "test://resource/1"; var subscription = await client.SubscribeToResourceAsync( @@ -299,7 +305,7 @@ public async Task SubscribeToResourceAsync_DisposalIsIdempotent() public async Task SubscribeToResourceAsync_MultipleHandlersSameUri_BothReceiveNotifications() { // Arrange - await using McpClient client = await CreateMcpClientForServer(); + await using McpClient client = await CreateLegacyMcpClientForServer(); const string resourceUri = "test://resource/1"; var handler1Called = new TaskCompletionSource(); var handler2Called = new TaskCompletionSource(); diff --git a/tests/ModelContextProtocol.Tests/Client/McpClientTaskMethodsTests.cs b/tests/ModelContextProtocol.Tests/Client/McpClientTaskMethodsTests.cs index ada9970cf..e3da699c4 100644 --- a/tests/ModelContextProtocol.Tests/Client/McpClientTaskMethodsTests.cs +++ b/tests/ModelContextProtocol.Tests/Client/McpClientTaskMethodsTests.cs @@ -1,33 +1,37 @@ +using ModelContextProtocol.Extensions.Tasks; using Microsoft.Extensions.DependencyInjection; -using Microsoft.Extensions.Options; using ModelContextProtocol.Client; using ModelContextProtocol.Protocol; using ModelContextProtocol.Server; +using System.Runtime.InteropServices; using System.Text.Json; +#pragma warning disable MCPEXP001 + namespace ModelContextProtocol.Tests.Client; +/// +/// Integration tests for the client-side task API methods: GetTaskAsync, CancelTaskAsync, +/// UpdateTaskAsync, CallToolAsTaskAsync, and the automatic polling in CallToolWithPollingAsync. +/// public class McpClientTaskMethodsTests : ClientServerTestBase { public McpClientTaskMethodsTests(ITestOutputHelper outputHelper) : base(outputHelper) { +#if !NET + Assert.SkipWhen(RuntimeInformation.IsOSPlatform(OSPlatform.Windows), "https://github.com/modelcontextprotocol/csharp-sdk/issues/587"); +#endif } protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) { - // Add task store for server-side task support - var taskStore = new InMemoryMcpTaskStore(); - services.AddSingleton(taskStore); - - // Configure server to use the task store directly - services.Configure(options => - { - options.TaskStore = taskStore; - }); - - // Add a simple tool for testing - mcpServerBuilder.WithTools([McpServerTool.Create( + mcpServerBuilder + .WithTasks(new InMemoryMcpTaskStore + { + DefaultPollIntervalMs = 50, + }) + .WithTools([McpServerTool.Create( async (string input, CancellationToken ct) => { await Task.Delay(50, ct); @@ -40,9 +44,8 @@ protected override void ConfigureServices(ServiceCollection services, IMcpServer })]); } - private static IDictionary CreateArguments(string key, object? value) + private static IDictionary CreateArguments(string key, string value) { - // For simple strings, just create a JsonElement from a string value return new Dictionary { [key] = JsonDocument.Parse($"\"{value}\"").RootElement.Clone() @@ -52,210 +55,197 @@ private static IDictionary CreateArguments(string key, obje [Fact] public async Task GetTaskAsync_ReturnsTaskStatus() { - await using McpClient client = await CreateMcpClientForServer(); + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; - // Create a task by calling a tool with task metadata - var callResult = await client.CallToolAsync( + var augmented = await client.CallToolAsTaskAsync( new CallToolRequestParams { Name = "test-tool", Arguments = CreateArguments("input", "test"), - Task = new McpTaskMetadata() - }, - cancellationToken: TestContext.Current.CancellationToken); + }, ct); + + Assert.True(augmented.IsTask); + var taskId = augmented.TaskCreated!.TaskId; + + // Get the task status + var task = await client.GetTaskAsync(taskId, ct); + Assert.NotNull(task); + } - // The response should contain task metadata - Assert.NotNull(callResult.Task); - - string taskId = callResult.Task.TaskId; + [Fact] + public async Task GetTaskAsync_UnknownTaskId_Throws() + { + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; - // Now get the task status - var task = await client.GetTaskAsync(taskId, cancellationToken: TestContext.Current.CancellationToken); + var ex = await Assert.ThrowsAsync(async () => + await client.GetTaskAsync("nonexistent-id", ct)); - Assert.Equal(taskId, task.TaskId); + Assert.Contains("Unknown task", ex.Message); } [Fact] - public async Task GetTaskAsync_ThrowsForInvalidTaskId() + public async Task GetTaskAsync_NullTaskId_Throws() { - await using McpClient client = await CreateMcpClientForServer(); + await using var client = await CreateMcpClientForServer(); - await Assert.ThrowsAsync(async () => - await client.GetTaskAsync("", cancellationToken: TestContext.Current.CancellationToken)); + await Assert.ThrowsAsync(async () => + await client.GetTaskAsync((string)null!, TestContext.Current.CancellationToken)); } [Fact] - public async Task GetTaskResultAsync_ReturnsDeserializedResult() + public async Task CallToolAsTaskAsync_WithTaskStore_ReturnsCreatedTask() { - await using McpClient client = await CreateMcpClientForServer(); + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; - // Create a task - var callResult = await client.CallToolAsync( + var augmented = await client.CallToolAsTaskAsync( new CallToolRequestParams { Name = "test-tool", Arguments = CreateArguments("input", "hello"), - Task = new McpTaskMetadata() - }, - cancellationToken: TestContext.Current.CancellationToken); - - Assert.NotNull(callResult.Task); - string taskId = callResult.Task.TaskId; + }, ct); - // Wait for task to complete and get the result - JsonElement result = await client.GetTaskResultAsync(taskId, cancellationToken: TestContext.Current.CancellationToken); - - // Verify the result has the expected CallToolResult shape - CallToolResult? toolResult = result.Deserialize(McpJsonUtilities.DefaultOptions); - Assert.NotNull(toolResult); - Assert.NotEmpty(toolResult.Content); - - TextContentBlock? textContent = toolResult.Content[0] as TextContentBlock; - Assert.NotNull(textContent); - Assert.Equal("Processed: hello", textContent.Text); + Assert.True(augmented.IsTask); + Assert.NotNull(augmented.TaskCreated); + Assert.Equal(McpTaskStatus.Working, augmented.TaskCreated.Status); + Assert.NotNull(augmented.TaskCreated.TaskId); + Assert.True(augmented.TaskCreated.PollIntervalMs > 0); } [Fact] - public async Task GetTaskResultAsync_ThrowsForInvalidTaskId() + public async Task CallToolAsync_PollsUntilCompletion_ReturnsResult() { - await using McpClient client = await CreateMcpClientForServer(); + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; + + var result = await client.CallToolWithPollingAsync( + new CallToolRequestParams + { + Name = "test-tool", + Arguments = CreateArguments("input", "hello"), + }, cancellationToken: ct); - await Assert.ThrowsAsync(async () => - await client.GetTaskResultAsync("", cancellationToken: TestContext.Current.CancellationToken)); + Assert.NotNull(result); + Assert.NotEmpty(result.Content); + var textContent = Assert.IsType(result.Content[0]); + Assert.Equal("Processed: hello", textContent.Text); } [Fact] - public async Task ListTasksAsync_ReturnsTasks() + public async Task CancelTaskAsync_ForWorkingTask_Succeeds() { - await using McpClient client = await CreateMcpClientForServer(); + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; - // Create a task - var callResult = await client.CallToolAsync( + var augmented = await client.CallToolAsTaskAsync( new CallToolRequestParams { Name = "test-tool", Arguments = CreateArguments("input", "test"), - Task = new McpTaskMetadata() - }, - cancellationToken: TestContext.Current.CancellationToken); + }, ct); - Assert.NotNull(callResult.Task); - string taskId = callResult.Task.TaskId; + Assert.True(augmented.IsTask); + var taskId = augmented.TaskCreated!.TaskId; - // List all tasks - var tasks = await client.ListTasksAsync(cancellationToken: TestContext.Current.CancellationToken); + // Cancel immediately (may succeed or fail depending on timing) + try + { + await client.CancelTaskAsync(taskId, ct); - Assert.NotNull(tasks); - Assert.Contains(tasks, t => t.TaskId == taskId); + // Cancellation is eventually consistent. The task may complete before the cancellation + // request wins the race, but the terminal-task cancellation acknowledgement is idempotent. + var taskResult = await client.GetTaskAsync(taskId, ct); + Assert.True(taskResult is CancelledTaskResult or CompletedTaskResult); + } + catch (McpProtocolException) + { + // Task may have already completed before we could cancel — that's fine + } } [Fact] - public async Task ListTasksAsync_HandlesEmptyResult() + public async Task CancelTaskAsync_NullTaskId_Throws() { - await using McpClient client = await CreateMcpClientForServer(); - - // List tasks (may or may not be empty depending on state) - var tasks = await client.ListTasksAsync(cancellationToken: TestContext.Current.CancellationToken); + await using var client = await CreateMcpClientForServer(); - Assert.NotNull(tasks); + await Assert.ThrowsAsync(async () => + await client.CancelTaskAsync((string)null!, cancellationToken: TestContext.Current.CancellationToken)); } [Fact] - public async Task ListTasksAsync_LowLevel_ReturnsRawResult() + public async Task CancelTaskAsync_UnknownTaskId_AcknowledgesIdempotently() { - await using McpClient client = await CreateMcpClientForServer(); - - // Create a task first - await client.CallToolAsync( - new CallToolRequestParams - { - Name = "test-tool", - Arguments = CreateArguments("input", "task1"), - Task = new McpTaskMetadata() - }, - cancellationToken: TestContext.Current.CancellationToken); + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; - // Use low-level API - var result = await client.ListTasksAsync(new ListTasksRequestParams(), TestContext.Current.CancellationToken); + // SEP-2663 requires servers to always acknowledge tasks/cancel, even when the task is + // unknown (e.g., has been garbage collected). The default handler must not throw. + var result = await client.CancelTaskAsync("nonexistent-id", ct); Assert.NotNull(result); - Assert.NotNull(result.Tasks); - } - - [Fact] - public async Task ListTasksAsync_LowLevel_ThrowsForNullParams() - { - await using McpClient client = await CreateMcpClientForServer(); - - await Assert.ThrowsAsync(async () => - await client.ListTasksAsync((ListTasksRequestParams)null!, TestContext.Current.CancellationToken)); } [Fact] - public async Task CancelTaskAsync_CancelsRunningTask() + public async Task GetTaskAsync_AfterCompletion_ReturnsCompletedResult() { - await using McpClient client = await CreateMcpClientForServer(); + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; - // Create a task - var callResult = await client.CallToolAsync( + var augmented = await client.CallToolAsTaskAsync( new CallToolRequestParams { Name = "test-tool", - Arguments = CreateArguments("input", "test"), - Task = new McpTaskMetadata() - }, - cancellationToken: TestContext.Current.CancellationToken); - - Assert.NotNull(callResult.Task); - string taskId = callResult.Task.TaskId; + Arguments = CreateArguments("input", "hello"), + }, ct); - // Cancel the task - var canceledTask = await client.CancelTaskAsync(taskId, cancellationToken: TestContext.Current.CancellationToken); + var taskId = augmented.TaskCreated!.TaskId; - Assert.Equal(taskId, canceledTask.TaskId); - } + // Poll until completed + GetTaskResult? taskResult = null; + for (int i = 0; i < 40; i++) + { + await Task.Delay(50, ct); + taskResult = await client.GetTaskAsync(taskId, ct); + if (taskResult is CompletedTaskResult) + { + break; + } + } - [Fact] - public async Task CancelTaskAsync_ThrowsForInvalidTaskId() - { - await using McpClient client = await CreateMcpClientForServer(); + var completed = Assert.IsType(taskResult); - await Assert.ThrowsAsync(async () => - await client.CancelTaskAsync("", cancellationToken: TestContext.Current.CancellationToken)); + // Deserialize the stored result + var toolResult = JsonSerializer.Deserialize(completed.Result, McpJsonUtilities.DefaultOptions); + Assert.NotNull(toolResult); + Assert.NotEmpty(toolResult.Content); + var textContent = Assert.IsType(toolResult.Content[0]); + Assert.Equal("Processed: hello", textContent.Text); } [Fact] - public async Task ListTasksAsync_HandlesPagination() + public async Task MultipleTasks_CreatedConcurrently_HaveUniqueIds() { - await using McpClient client = await CreateMcpClientForServer(); + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; + + var taskIds = new HashSet(); - // Create multiple tasks - var taskIds = new List(); - for (int i = 0; i < 3; i++) + for (int i = 0; i < 5; i++) { - var result = await client.CallToolAsync( + var augmented = await client.CallToolAsTaskAsync( new CallToolRequestParams { Name = "test-tool", Arguments = CreateArguments("input", $"task-{i}"), - Task = new McpTaskMetadata() - }, - cancellationToken: TestContext.Current.CancellationToken); - - Assert.NotNull(result.Task); - taskIds.Add(result.Task.TaskId); - } - - // List all tasks (should handle pagination automatically if needed) - var tasks = await client.ListTasksAsync(cancellationToken: TestContext.Current.CancellationToken); + }, ct); - Assert.NotNull(tasks); - Assert.True(tasks.Count >= taskIds.Count, "Should retrieve at least the tasks we created"); - - // Verify all our tasks are in the result - foreach (var taskId in taskIds) - { - Assert.Contains(tasks, t => t.TaskId == taskId); + Assert.True(augmented.IsTask); + taskIds.Add(augmented.TaskCreated!.TaskId); } + + // All task IDs should be unique + Assert.Equal(5, taskIds.Count); } } diff --git a/tests/ModelContextProtocol.Tests/Client/McpClientTaskSamplingElicitationTests.cs b/tests/ModelContextProtocol.Tests/Client/McpClientTaskSamplingElicitationTests.cs deleted file mode 100644 index 906b4f491..000000000 --- a/tests/ModelContextProtocol.Tests/Client/McpClientTaskSamplingElicitationTests.cs +++ /dev/null @@ -1,867 +0,0 @@ -using Microsoft.Extensions.DependencyInjection; -using ModelContextProtocol.Client; -using ModelContextProtocol.Protocol; -using ModelContextProtocol.Server; -using ModelContextProtocol.Tests.Utils; -using System.Text.Json; - -namespace ModelContextProtocol.Tests.Client; - -/// -/// Integration tests for task-based sampling and elicitation on the client side. -/// Tests the client's ability to receive task-augmented requests from the server, -/// execute them as tasks, and report results. -/// -public class McpClientTaskSamplingElicitationTests : ClientServerTestBase -{ - public McpClientTaskSamplingElicitationTests(ITestOutputHelper outputHelper) - : base(outputHelper) - { - } - - protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) - { - // Add task store for server-side task support - var taskStore = new InMemoryMcpTaskStore(); - services.AddSingleton(taskStore); - - // Configure server to use the task store - services.Configure(options => - { - options.TaskStore = taskStore; - }); - - // Add a tool that uses sampling to generate responses - mcpServerBuilder.WithTools([McpServerTool.Create( - async (string prompt, McpServer server, CancellationToken ct) => - { - // This tool requests sampling from the client - var result = await server.SampleAsync(new CreateMessageRequestParams - { - Messages = [new SamplingMessage { Role = Role.User, Content = [new TextContentBlock { Text = prompt }] }], - MaxTokens = 100 - }, ct); - - return result.Content.OfType().FirstOrDefault()?.Text ?? "No response"; - }, - new McpServerToolCreateOptions - { - Name = "sample-tool", - Description = "A tool that uses sampling" - }), - McpServerTool.Create( - async (string message, McpServer server, CancellationToken ct) => - { - // This tool requests elicitation from the client - var result = await server.ElicitAsync(new ElicitRequestParams - { - Message = message, - RequestedSchema = new() - }, ct); - - return result.Action == "confirm" ? "Confirmed" : "Declined"; - }, - new McpServerToolCreateOptions - { - Name = "elicit-tool", - Description = "A tool that uses elicitation" - })]); - } - - private static IDictionary CreateArguments(string key, object? value) - { - return new Dictionary - { - [key] = JsonDocument.Parse($"\"{value}\"").RootElement.Clone() - }; - } - - #region Client Task-Based Sampling Tests - - [Fact] - public async Task Client_WithTaskStoreAndSamplingHandler_AdvertisesTaskAugmentedSamplingCapability() - { - // Arrange - Create client with task store and sampling handler - var taskStore = new InMemoryMcpTaskStore(); - var clientOptions = new McpClientOptions - { - TaskStore = taskStore, - Handlers = new McpClientHandlers - { - SamplingHandler = (request, progress, ct) => - { - return new ValueTask(new CreateMessageResult - { - Content = [new TextContentBlock { Text = "Sampled response" }], - Model = "test-model" - }); - } - } - }; - - await using McpClient client = await CreateMcpClientForServer(clientOptions); - - // The server should see the client's task capabilities - // We verify by checking server can use task-augmented requests - Assert.NotNull(Server.ClientCapabilities); - Assert.NotNull(Server.ClientCapabilities.Sampling); - Assert.NotNull(Server.ClientCapabilities.Tasks); - Assert.NotNull(Server.ClientCapabilities.Tasks.Requests?.Sampling?.CreateMessage); - } - - [Fact] - public async Task Client_WithoutTaskStore_DoesNotAdvertiseTaskAugmentedSamplingCapability() - { - // Arrange - Create client with sampling handler but NO task store - var clientOptions = new McpClientOptions - { - // No TaskStore configured - Handlers = new McpClientHandlers - { - SamplingHandler = (request, progress, ct) => - { - return new ValueTask(new CreateMessageResult - { - Content = [new TextContentBlock { Text = "Sampled response" }], - Model = "test-model" - }); - } - } - }; - - await using McpClient client = await CreateMcpClientForServer(clientOptions); - - // The server should see sampling capability but NOT task-augmented sampling - Assert.NotNull(Server.ClientCapabilities); - Assert.NotNull(Server.ClientCapabilities.Sampling); - - // Task capabilities should be null (no task store) - Assert.Null(Server.ClientCapabilities.Tasks); - } - - [Fact] - public async Task Server_SampleAsTaskAsync_FailsWhenClientDoesNotSupportTaskAugmentedSampling() - { - // Arrange - Client with sampling handler but NO task store - var clientOptions = new McpClientOptions - { - Handlers = new McpClientHandlers - { - SamplingHandler = (request, progress, ct) => - { - return new ValueTask(new CreateMessageResult - { - Content = [new TextContentBlock { Text = "Response" }], - Model = "model" - }); - } - } - }; - - await using McpClient client = await CreateMcpClientForServer(clientOptions); - - // Act & Assert - Server should throw when trying to use task-augmented sampling - var exception = await Assert.ThrowsAsync(async () => - { - await Server.SampleAsTaskAsync( - new CreateMessageRequestParams - { - Messages = [new SamplingMessage { Role = Role.User, Content = [new TextContentBlock { Text = "Test" }] }], - MaxTokens = 100 - }, - new McpTaskMetadata(), - TestContext.Current.CancellationToken); - }); - - Assert.Contains("task-augmented sampling", exception.Message, StringComparison.OrdinalIgnoreCase); - } - - [Fact] - public async Task Client_WithTaskStore_CanExecuteSamplingAsTask() - { - // Arrange - var taskStore = new InMemoryMcpTaskStore(); - var samplingCompleted = new TaskCompletionSource(); - - var clientOptions = new McpClientOptions - { - TaskStore = taskStore, - Handlers = new McpClientHandlers - { - SamplingHandler = async (request, progress, ct) => - { - // Simulate some work - await Task.Delay(50, ct); - samplingCompleted.TrySetResult(true); - return new CreateMessageResult - { - Content = [new TextContentBlock { Text = "Task-based sampling response" }], - Model = "test-model" - }; - } - } - }; - - await using McpClient client = await CreateMcpClientForServer(clientOptions); - - // Act - Server requests task-augmented sampling - var mcpTask = await Server.SampleAsTaskAsync( - new CreateMessageRequestParams - { - Messages = [new SamplingMessage { Role = Role.User, Content = [new TextContentBlock { Text = "Hello" }] }], - MaxTokens = 100 - }, - new McpTaskMetadata(), - TestContext.Current.CancellationToken); - - // Assert - Task was created - Assert.NotNull(mcpTask); - Assert.NotEmpty(mcpTask.TaskId); - Assert.Equal(McpTaskStatus.Working, mcpTask.Status); - - // Wait for sampling to complete - await samplingCompleted.Task.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); - - // Poll until task is complete - McpTask taskStatus; - do - { - await Task.Delay(100, TestContext.Current.CancellationToken); - taskStatus = await Server.GetTaskAsync(mcpTask.TaskId, TestContext.Current.CancellationToken); - } - while (taskStatus.Status == McpTaskStatus.Working); - - Assert.Equal(McpTaskStatus.Completed, taskStatus.Status); - - // Get the result - var result = await Server.GetTaskResultAsync( - mcpTask.TaskId, cancellationToken: TestContext.Current.CancellationToken); - - Assert.NotNull(result); - var textContent = Assert.IsType(Assert.Single(result.Content)); - Assert.Equal("Task-based sampling response", textContent.Text); - } - - #endregion - - #region Client Task-Based Elicitation Tests - - [Fact] - public async Task Client_WithTaskStoreAndElicitationHandler_AdvertisesTaskAugmentedElicitationCapability() - { - // Arrange - Create client with task store and elicitation handler - var taskStore = new InMemoryMcpTaskStore(); - var clientOptions = new McpClientOptions - { - TaskStore = taskStore, - Handlers = new McpClientHandlers - { - ElicitationHandler = (request, ct) => - { - return new ValueTask(new ElicitResult { Action = "confirm" }); - } - } - }; - - await using McpClient client = await CreateMcpClientForServer(clientOptions); - - // Verify client advertised task-augmented elicitation - Assert.NotNull(Server.ClientCapabilities); - Assert.NotNull(Server.ClientCapabilities.Elicitation); - Assert.NotNull(Server.ClientCapabilities.Tasks); - Assert.NotNull(Server.ClientCapabilities.Tasks.Requests?.Elicitation?.Create); - } - - [Fact] - public async Task Client_WithoutTaskStore_DoesNotAdvertiseTaskAugmentedElicitationCapability() - { - // Arrange - Create client with elicitation handler but NO task store - var clientOptions = new McpClientOptions - { - // No TaskStore configured - Handlers = new McpClientHandlers - { - ElicitationHandler = (request, ct) => - { - return new ValueTask(new ElicitResult { Action = "confirm" }); - } - } - }; - - await using McpClient client = await CreateMcpClientForServer(clientOptions); - - // Verify elicitation is supported but NOT task-augmented - Assert.NotNull(Server.ClientCapabilities); - Assert.NotNull(Server.ClientCapabilities.Elicitation); - Assert.Null(Server.ClientCapabilities.Tasks); - } - - [Fact] - public async Task Server_ElicitAsTaskAsync_FailsWhenClientDoesNotSupportTaskAugmentedElicitation() - { - // Arrange - Client with elicitation handler but NO task store - var clientOptions = new McpClientOptions - { - Handlers = new McpClientHandlers - { - ElicitationHandler = (request, ct) => - { - return new ValueTask(new ElicitResult { Action = "confirm" }); - } - } - }; - - await using McpClient client = await CreateMcpClientForServer(clientOptions); - - // Act & Assert - Server should throw when trying to use task-augmented elicitation - var exception = await Assert.ThrowsAsync(async () => - { - await Server.ElicitAsTaskAsync( - new ElicitRequestParams - { - Message = "Please confirm", - RequestedSchema = new() - }, - new McpTaskMetadata(), - TestContext.Current.CancellationToken); - }); - - Assert.Contains("task-augmented elicitation", exception.Message, StringComparison.OrdinalIgnoreCase); - } - - [Fact] - public async Task Client_WithTaskStore_CanExecuteElicitationAsTask() - { - // Arrange - var taskStore = new InMemoryMcpTaskStore(); - var elicitationCompleted = new TaskCompletionSource(); - - var clientOptions = new McpClientOptions - { - TaskStore = taskStore, - Handlers = new McpClientHandlers - { - ElicitationHandler = async (request, ct) => - { - // Simulate user interaction time - await Task.Delay(50, ct); - elicitationCompleted.TrySetResult(true); - return new ElicitResult - { - Action = "accept", - Content = new Dictionary - { - ["answer"] = JsonDocument.Parse("\"yes\"").RootElement.Clone() - } - }; - } - } - }; - - await using McpClient client = await CreateMcpClientForServer(clientOptions); - - // Act - Server requests task-augmented elicitation - var mcpTask = await Server.ElicitAsTaskAsync( - new ElicitRequestParams - { - Message = "Do you want to proceed?", - RequestedSchema = new() - }, - new McpTaskMetadata(), - TestContext.Current.CancellationToken); - - // Assert - Task was created - Assert.NotNull(mcpTask); - Assert.NotEmpty(mcpTask.TaskId); - Assert.Equal(McpTaskStatus.Working, mcpTask.Status); - - // Wait for elicitation to complete - await elicitationCompleted.Task.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); - - // Poll until task is complete - McpTask taskStatus; - do - { - await Task.Delay(100, TestContext.Current.CancellationToken); - taskStatus = await Server.GetTaskAsync(mcpTask.TaskId, TestContext.Current.CancellationToken); - } - while (taskStatus.Status == McpTaskStatus.Working); - - Assert.Equal(McpTaskStatus.Completed, taskStatus.Status); - - // Get the result - var result = await Server.GetTaskResultAsync( - mcpTask.TaskId, cancellationToken: TestContext.Current.CancellationToken); - - Assert.NotNull(result); - Assert.Equal("accept", result.Action); - } - - #endregion - - #region Client Task Reporting Tests - - [Fact] - public async Task Client_CanListOwnTasks() - { - // Arrange - var taskStore = new InMemoryMcpTaskStore(); - var clientOptions = new McpClientOptions - { - TaskStore = taskStore, - Handlers = new McpClientHandlers - { - SamplingHandler = async (request, progress, ct) => - { - await Task.Delay(50, ct); - return new CreateMessageResult - { - Content = [new TextContentBlock { Text = "Response" }], - Model = "model" - }; - } - } - }; - - await using McpClient client = await CreateMcpClientForServer(clientOptions); - - // Create multiple tasks - var task1 = await Server.SampleAsTaskAsync( - new CreateMessageRequestParams { Messages = [], MaxTokens = 100 }, - new McpTaskMetadata(), - TestContext.Current.CancellationToken); - - var task2 = await Server.SampleAsTaskAsync( - new CreateMessageRequestParams { Messages = [], MaxTokens = 100 }, - new McpTaskMetadata(), - TestContext.Current.CancellationToken); - - // Act - Server lists tasks from client - var tasks = await Server.ListTasksAsync(TestContext.Current.CancellationToken); - - // Assert - Assert.NotNull(tasks); - Assert.True(tasks.Count >= 2, "Should have at least 2 tasks"); - Assert.Contains(tasks, t => t.TaskId == task1.TaskId); - Assert.Contains(tasks, t => t.TaskId == task2.TaskId); - } - - [Fact] - public async Task Client_CanCancelTasks() - { - // Arrange - var taskStore = new InMemoryMcpTaskStore(); - var samplingStarted = new TaskCompletionSource(); - var allowCompletion = new TaskCompletionSource(); - - var clientOptions = new McpClientOptions - { - TaskStore = taskStore, - Handlers = new McpClientHandlers - { - SamplingHandler = async (request, progress, ct) => - { - samplingStarted.TrySetResult(true); - // Wait for either completion signal or cancellation - try - { - await allowCompletion.Task.WaitAsync(ct); - } - catch (OperationCanceledException) - { - throw; - } - return new CreateMessageResult - { - Content = [new TextContentBlock { Text = "Should not reach here" }], - Model = "model" - }; - } - } - }; - - await using McpClient client = await CreateMcpClientForServer(clientOptions); - - // Create a task that will be in progress - var mcpTask = await Server.SampleAsTaskAsync( - new CreateMessageRequestParams { Messages = [], MaxTokens = 100 }, - new McpTaskMetadata(), - TestContext.Current.CancellationToken); - - // Wait for sampling to start - await samplingStarted.Task.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); - - // Act - Cancel the task - var cancelledTask = await Server.CancelTaskAsync(mcpTask.TaskId, TestContext.Current.CancellationToken); - - // Assert - Assert.NotNull(cancelledTask); - Assert.Equal(McpTaskStatus.Cancelled, cancelledTask.Status); - - // Allow completion to avoid hanging (the handler might still be running) - allowCompletion.TrySetResult(true); - } - - [Fact] - public async Task Client_TaskStatusNotifications_SentWhenEnabled() - { - // Arrange - var taskStore = new InMemoryMcpTaskStore(); - var workingNotificationReceived = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - var completedNotificationReceived = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - var notificationsReceived = new List(); - var notificationsLock = new object(); - string? expectedTaskId = null; - var expectedTaskIdLock = new object(); - - var clientOptions = new McpClientOptions - { - TaskStore = taskStore, - SendTaskStatusNotifications = true, - Handlers = new McpClientHandlers - { - SamplingHandler = async (request, progress, ct) => - { - await Task.Delay(100, ct); - return new CreateMessageResult - { - Content = [new TextContentBlock { Text = "Done" }], - Model = "model" - }; - } - } - }; - - // Register notification handler on the server BEFORE creating the client - var notificationHandler = Server.RegisterNotificationHandler( - NotificationMethods.TaskStatusNotification, - (notification, ct) => - { - if (notification.Params is not { } paramsNode) - { - return default; - } - - var taskNotification = JsonSerializer.Deserialize( - paramsNode, McpJsonUtilities.DefaultOptions); - if (taskNotification is null) - { - return default; - } - - // Only track notifications for our task - string? taskId; - lock (expectedTaskIdLock) - { - taskId = expectedTaskId; - } - if (taskId is not null && taskNotification.TaskId != taskId) - { - return default; - } - - lock (notificationsLock) - { - notificationsReceived.Add(new McpTask - { - TaskId = taskNotification.TaskId, - Status = taskNotification.Status, - CreatedAt = taskNotification.CreatedAt, - LastUpdatedAt = taskNotification.LastUpdatedAt - }); - } - - // Signal when we receive the Working and Completed notifications - if (taskNotification.Status == McpTaskStatus.Working) - { - workingNotificationReceived.TrySetResult(true); - } - else if (taskNotification.Status == McpTaskStatus.Completed) - { - completedNotificationReceived.TrySetResult(true); - } - - return default; - }); - - await using McpClient client = await CreateMcpClientForServer(clientOptions); - - // Act - Create a task - var mcpTask = await Server.SampleAsTaskAsync( - new CreateMessageRequestParams { Messages = [], MaxTokens = 100 }, - new McpTaskMetadata(), - TestContext.Current.CancellationToken); - - // Store the expected task ID for filtering - lock (expectedTaskIdLock) - { - expectedTaskId = mcpTask.TaskId; - } - - // Wait for both Working and Completed notifications to arrive - // The notifications are sent asynchronously so we need to wait for both - await Task.WhenAll( - workingNotificationReceived.Task.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken), - completedNotificationReceived.Task.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken)); - - // Assert - Should have received notifications for status transitions - await notificationHandler.DisposeAsync(); - - List notifications; - lock (notificationsLock) - { - notifications = [.. notificationsReceived]; - } - - Assert.NotEmpty(notifications); - Assert.Contains(notifications, t => t.Status == McpTaskStatus.Working); - Assert.Contains(notifications, t => t.Status == McpTaskStatus.Completed); - - // Verify all notifications are for the correct task - Assert.All(notifications, t => Assert.Equal(mcpTask.TaskId, t.TaskId)); - } - - #endregion - - #region Error Handling Tests - - [Fact] - public async Task Client_SamplingHandlerException_ResultsInFailedTask() - { - // Arrange - var taskStore = new InMemoryMcpTaskStore(); - var samplingAttempted = new TaskCompletionSource(); - - var clientOptions = new McpClientOptions - { - TaskStore = taskStore, - Handlers = new McpClientHandlers - { - SamplingHandler = (request, progress, ct) => - { - samplingAttempted.TrySetResult(true); - throw new InvalidOperationException("Sampling failed!"); - } - } - }; - - await using McpClient client = await CreateMcpClientForServer(clientOptions); - - // Act - var mcpTask = await Server.SampleAsTaskAsync( - new CreateMessageRequestParams { Messages = [], MaxTokens = 100 }, - new McpTaskMetadata(), - TestContext.Current.CancellationToken); - - // Wait for sampling attempt - await samplingAttempted.Task.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); - - // Poll until task status changes - McpTask taskStatus; - do - { - await Task.Delay(100, TestContext.Current.CancellationToken); - taskStatus = await Server.GetTaskAsync(mcpTask.TaskId, TestContext.Current.CancellationToken); - } - while (taskStatus.Status == McpTaskStatus.Working); - - // Assert - Task should be in failed state - Assert.Equal(McpTaskStatus.Failed, taskStatus.Status); - Assert.NotNull(taskStatus.StatusMessage); - Assert.Contains("Sampling failed!", taskStatus.StatusMessage); - } - - [Fact] - public async Task Client_ElicitationHandlerException_ResultsInFailedTask() - { - // Arrange - var taskStore = new InMemoryMcpTaskStore(); - var elicitationAttempted = new TaskCompletionSource(); - - var clientOptions = new McpClientOptions - { - TaskStore = taskStore, - Handlers = new McpClientHandlers - { - ElicitationHandler = (request, ct) => - { - elicitationAttempted.TrySetResult(true); - throw new InvalidOperationException("Elicitation failed!"); - } - } - }; - - await using McpClient client = await CreateMcpClientForServer(clientOptions); - - // Act - var mcpTask = await Server.ElicitAsTaskAsync( - new ElicitRequestParams - { - Message = "Test", - RequestedSchema = new() - }, - new McpTaskMetadata(), - TestContext.Current.CancellationToken); - - // Wait for elicitation attempt - await elicitationAttempted.Task.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); - - // Poll until task status changes - McpTask taskStatus; - do - { - await Task.Delay(100, TestContext.Current.CancellationToken); - taskStatus = await Server.GetTaskAsync(mcpTask.TaskId, TestContext.Current.CancellationToken); - } - while (taskStatus.Status == McpTaskStatus.Working); - - // Assert - Assert.Equal(McpTaskStatus.Failed, taskStatus.Status); - Assert.NotNull(taskStatus.StatusMessage); - Assert.Contains("Elicitation failed!", taskStatus.StatusMessage); - } - - #endregion - - #region Capability Validation Tests - - [Fact] - public async Task Client_WithOnlySamplingHandler_OnlyAdvertisesSamplingTasks() - { - // Arrange - Client with only sampling handler and task store - var taskStore = new InMemoryMcpTaskStore(); - var clientOptions = new McpClientOptions - { - TaskStore = taskStore, - Handlers = new McpClientHandlers - { - SamplingHandler = (request, progress, ct) => - { - return new ValueTask(new CreateMessageResult - { - Content = [new TextContentBlock { Text = "Response" }], - Model = "model" - }); - } - // No ElicitationHandler - } - }; - - await using McpClient client = await CreateMcpClientForServer(clientOptions); - - // Assert - Assert.NotNull(Server.ClientCapabilities); - Assert.NotNull(Server.ClientCapabilities.Tasks); - - // Should have sampling task capability - Assert.NotNull(Server.ClientCapabilities.Tasks.Requests?.Sampling?.CreateMessage); - - // Should NOT have elicitation task capability - Assert.Null(Server.ClientCapabilities.Tasks.Requests?.Elicitation); - } - - [Fact] - public async Task Client_WithOnlyElicitationHandler_OnlyAdvertisesElicitationTasks() - { - // Arrange - Client with only elicitation handler and task store - var taskStore = new InMemoryMcpTaskStore(); - var clientOptions = new McpClientOptions - { - TaskStore = taskStore, - Handlers = new McpClientHandlers - { - ElicitationHandler = (request, ct) => - { - return new ValueTask(new ElicitResult { Action = "confirm" }); - } - // No SamplingHandler - } - }; - - await using McpClient client = await CreateMcpClientForServer(clientOptions); - - // Assert - Assert.NotNull(Server.ClientCapabilities); - Assert.NotNull(Server.ClientCapabilities.Tasks); - - // Should have elicitation task capability - Assert.NotNull(Server.ClientCapabilities.Tasks.Requests?.Elicitation?.Create); - - // Should NOT have sampling task capability - Assert.Null(Server.ClientCapabilities.Tasks.Requests?.Sampling); - } - - [Fact] - public async Task Client_WithBothHandlers_AdvertisesBothTaskCapabilities() - { - // Arrange - Client with both handlers and task store - var taskStore = new InMemoryMcpTaskStore(); - var clientOptions = new McpClientOptions - { - TaskStore = taskStore, - Handlers = new McpClientHandlers - { - SamplingHandler = (request, progress, ct) => - { - return new ValueTask(new CreateMessageResult - { - Content = [new TextContentBlock { Text = "Response" }], - Model = "model" - }); - }, - ElicitationHandler = (request, ct) => - { - return new ValueTask(new ElicitResult { Action = "confirm" }); - } - } - }; - - await using McpClient client = await CreateMcpClientForServer(clientOptions); - - // Assert - Assert.NotNull(Server.ClientCapabilities); - Assert.NotNull(Server.ClientCapabilities.Tasks); - Assert.NotNull(Server.ClientCapabilities.Tasks.Requests); - - // Should have both capabilities - Assert.NotNull(Server.ClientCapabilities.Tasks.Requests.Sampling?.CreateMessage); - Assert.NotNull(Server.ClientCapabilities.Tasks.Requests.Elicitation?.Create); - - // Should also have list and cancel capabilities - Assert.NotNull(Server.ClientCapabilities.Tasks.List); - Assert.NotNull(Server.ClientCapabilities.Tasks.Cancel); - } - - [Fact] - public async Task Client_WithNoHandlers_DoesNotAdvertiseTaskCapabilities() - { - // Arrange - Client with task store but no handlers - var taskStore = new InMemoryMcpTaskStore(); - var clientOptions = new McpClientOptions - { - TaskStore = taskStore, - Handlers = new McpClientHandlers() - // No handlers configured - }; - - await using McpClient client = await CreateMcpClientForServer(clientOptions); - - // Assert - No capabilities should be advertised without handlers - Assert.NotNull(Server.ClientCapabilities); - - // Note: Tasks capability is advertised based on task store being present, - // but request types depend on specific handlers - if (Server.ClientCapabilities.Tasks is not null) - { - // If Tasks is present, requests should be null or have no request types - var requests = Server.ClientCapabilities.Tasks.Requests; - if (requests is not null) - { - Assert.Null(requests.Sampling); - Assert.Null(requests.Elicitation); - } - } - } - - #endregion -} diff --git a/tests/ModelContextProtocol.Tests/Client/McpClientTests.cs b/tests/ModelContextProtocol.Tests/Client/McpClientTests.cs index 262efbd40..aefe6a962 100644 --- a/tests/ModelContextProtocol.Tests/Client/McpClientTests.cs +++ b/tests/ModelContextProtocol.Tests/Client/McpClientTests.cs @@ -483,7 +483,7 @@ private sealed class SynchronousProgress(Action callb [Fact] public async Task AsClientLoggerProvider_MessagesSentToClient() { - await using McpClient client = await CreateMcpClientForServer(); + await using McpClient client = await CreateMcpClientForServer(new McpClientOptions { ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion }); ILoggerProvider loggerProvider = Server.AsClientLoggerProvider(); Assert.Throws("categoryName", () => loggerProvider.CreateLogger(null!)); @@ -584,7 +584,16 @@ public async Task AsClientLoggerProvider_MessagesSentToClient() public async Task ReturnsNegotiatedProtocolVersion(string? protocolVersion) { await using McpClient client = await CreateMcpClientForServer(new() { ProtocolVersion = protocolVersion }); - Assert.Equal(protocolVersion ?? "2025-11-25", client.NegotiatedProtocolVersion); + // A null ProtocolVersion now prefers the 2026-07-28 protocol, which the reactive test server advertises. + Assert.Equal(protocolVersion ?? "2026-07-28", client.NegotiatedProtocolVersion); + } + + [Fact] + public async Task ReturnsNegotiatedProtocolVersion_WithExperimentalProtocol() + { + Server.ServerOptions.ProtocolVersion = "2026-07-28"; + await using McpClient client = await CreateMcpClientForServer(new() { ProtocolVersion = "2026-07-28" }); + Assert.Equal("2026-07-28", client.NegotiatedProtocolVersion); } [Fact] @@ -756,7 +765,7 @@ await Assert.ThrowsAsync("requestParams", [Fact] public async Task SetLoggingLevelAsync_WithRequestParams_SetsLevel() { - await using McpClient client = await CreateMcpClientForServer(); + await using McpClient client = await CreateMcpClientForServer(new McpClientOptions { ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion }); // Should not throw await client.SetLoggingLevelAsync( @@ -786,7 +795,9 @@ await Assert.ThrowsAsync("requestParams", [Fact] public async Task ServerCanPingClient() { - await using McpClient client = await CreateMcpClientForServer(); + // ping is available only on initialize-handshake revisions (removed in the 2026-07-28 protocol + // per SEP-2575), so pin the client to exercise the server-initiated ping round-trip. + await using McpClient client = await CreateMcpClientForServer(new() { ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion }); var pingRequest = new JsonRpcRequest { Method = RequestMethods.Ping }; var response = await Server.SendRequestAsync(pingRequest, TestContext.Current.CancellationToken); diff --git a/tests/ModelContextProtocol.Tests/Client/McpClientToolRejectionTests.cs b/tests/ModelContextProtocol.Tests/Client/McpClientToolRejectionTests.cs new file mode 100644 index 000000000..cd3ddde7f --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Client/McpClientToolRejectionTests.cs @@ -0,0 +1,67 @@ +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.Text.Json; + +namespace ModelContextProtocol.Tests.Client; + +public class McpClientToolRejectionTests : ClientServerTestBase +{ + private const string InvalidToolName = "InvalidHeaderTool"; + private const string ValidToolName = "ValidTool"; + + public McpClientToolRejectionTests(ITestOutputHelper outputHelper) + : base(outputHelper) + { + } + + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + // Register a valid tool. + mcpServerBuilder.WithTools([McpServerTool.Create( + (string input) => $"echo {input}", + new() { Name = ValidToolName })]); + + // Register a tool whose InputSchema has an invalid x-mcp-header (colon in header name). + var invalidTool = McpServerTool.Create( + (string region) => $"result for {region}", + new() { Name = InvalidToolName }); + + // Manually inject an invalid x-mcp-header annotation into the schema. + // The header name "Invalid:Header" contains a colon, which is prohibited. + var schemaJson = """ + { + "type": "object", + "properties": { + "region": { + "type": "string", + "x-mcp-header": "Invalid:Header" + } + } + } + """; + invalidTool.ProtocolTool.InputSchema = JsonDocument.Parse(schemaJson).RootElement.Clone(); + + mcpServerBuilder.WithTools([invalidTool]); + } + + [Fact] + public async Task ListToolsAsync_ExcludesToolWithInvalidXMcpHeader_AndLogsWarning() + { + // Act + await using var client = await CreateMcpClientForServer(); + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + // Assert: the valid tool is returned, the invalid one is excluded. + Assert.Contains(tools, t => t.Name == ValidToolName); + Assert.DoesNotContain(tools, t => t.Name == InvalidToolName); + + // Assert: a warning was logged about the rejected tool. + Assert.Contains(MockLoggerProvider.LogMessages, log => + log.LogLevel == LogLevel.Warning && + log.Message.Contains(InvalidToolName) && + log.Message.Contains("excluded")); + } +} diff --git a/tests/ModelContextProtocol.Tests/Client/McpHeaderEncoderTests.cs b/tests/ModelContextProtocol.Tests/Client/McpHeaderEncoderTests.cs new file mode 100644 index 000000000..1e4fc00ef --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Client/McpHeaderEncoderTests.cs @@ -0,0 +1,213 @@ +using ModelContextProtocol.Protocol; + +namespace ModelContextProtocol.Tests.Client; + +public class McpHeaderEncoderTests +{ + [Theory] + [InlineData("us-west1", "us-west1")] + [InlineData("hello-world", "hello-world")] + [InlineData("my_tool_name", "my_tool_name")] + [InlineData("us west 1", "us west 1")] + [InlineData("", "")] + public void EncodeValue_PlainAscii_PassesThrough(string input, string expected) + { + var result = McpHeaderEncoder.EncodeValue(input); + Assert.Equal(expected, result); + } + + [Theory] + [InlineData(" us-west1", "=?base64?IHVzLXdlc3Qx?=")] + [InlineData("us-west1 ", "=?base64?dXMtd2VzdDEg?=")] + [InlineData(" us-west1 ", "=?base64?IHVzLXdlc3QxIA==?=")] + [InlineData("\tindented", "=?base64?CWluZGVudGVk?=")] + public void EncodeValue_LeadingTrailingWhitespace_Base64Encodes(string input, string expected) + { + var result = McpHeaderEncoder.EncodeValue(input); + Assert.Equal(expected, result); + } + + [Fact] + public void EncodeValue_NonAsciiCharacters_Base64Encodes() + { + var result = McpHeaderEncoder.EncodeValue("日本語"); + Assert.Equal("=?base64?5pel5pys6Kqe?=", result); + } + + [Fact] + public void EncodeValue_NewlineCharacter_Base64Encodes() + { + var result = McpHeaderEncoder.EncodeValue("line1\nline2"); + Assert.Equal("=?base64?bGluZTEKbGluZTI=?=", result); + } + + [Fact] + public void EncodeValue_CarriageReturnNewline_Base64Encodes() + { + var result = McpHeaderEncoder.EncodeValue("line1\r\nline2"); + Assert.Equal("=?base64?bGluZTENCmxpbmUy?=", result); + } + + [Theory] + [InlineData(true, "true")] + [InlineData(false, "false")] + public void EncodeValue_Boolean_ConvertsToLowercase(bool input, string expected) + { + var result = McpHeaderEncoder.EncodeValue(input); + Assert.Equal(expected, result); + } + + [Theory] + [InlineData(42, "42")] + [InlineData(0, "0")] + [InlineData(-1, "-1")] + public void EncodeValue_Integer_ConvertsToString(object input, string expected) + { + var result = McpHeaderEncoder.EncodeValue(input); + Assert.Equal(expected, result); + } + + [Fact] + public void EncodeValue_Null_ReturnsNull() + { + var result = McpHeaderEncoder.EncodeValue(null); + Assert.Null(result); + } + + [Fact] + public void EncodeValue_UnsupportedType_ReturnsNull() + { + var result = McpHeaderEncoder.EncodeValue(new object()); + Assert.Null(result); + } + + [Theory] + [InlineData("us-west1", "us-west1")] + [InlineData("", "")] + public void DecodeValue_PlainAscii_ReturnsAsIs(string input, string expected) + { + var result = McpHeaderEncoder.DecodeValue(input); + Assert.Equal(expected, result); + } + + [Fact] + public void DecodeValue_Null_ReturnsNull() + { + var result = McpHeaderEncoder.DecodeValue(null); + Assert.Null(result); + } + + [Fact] + public void DecodeValue_ValidBase64_Decodes() + { + var result = McpHeaderEncoder.DecodeValue("=?base64?SGVsbG8=?="); + Assert.Equal("Hello", result); + } + + [Fact] + public void DecodeValue_DegenerateWrapper_ReturnsLiteralValue() + { + // "=?base64?=" matches both the prefix "=?base64?" and the suffix "?=" because they + // overlap on the shared '?', but it is too short to contain any base64 content. It must be + // returned as-is rather than throwing when the wrapper is stripped. + var result = McpHeaderEncoder.DecodeValue("=?base64?="); + Assert.Equal("=?base64?=", result); + } + + [Fact] + public void DecodeValue_CaseSensitivePrefix_ReturnsLiteralValue() + { + // Per SEP-2243: sentinel markers are case-sensitive and MUST appear exactly as shown (lowercase). + // An uppercase prefix should NOT be decoded as base64. + var result = McpHeaderEncoder.DecodeValue("=?BASE64?SGVsbG8=?="); + Assert.Equal("=?BASE64?SGVsbG8=?=", result); + } + + [Fact] + public void DecodeValue_InvalidBase64_ReturnsNull() + { + var result = McpHeaderEncoder.DecodeValue("=?base64?SGVs!!!bG8=?="); + Assert.Null(result); + } + + [Fact] + public void DecodeValue_ValidBase64ButInvalidUtf8_ReturnsNull() + { + // "//4=" is valid Base64 that decodes to the bytes 0xFF 0xFE, which are not valid UTF-8. + // A strict decoder must reject this rather than substituting U+FFFD replacement characters. + var result = McpHeaderEncoder.DecodeValue("=?base64?//4=?="); + Assert.Null(result); + } + + [Fact] + public void DecodeValue_MissingPrefix_ReturnsLiteralValue() + { + var result = McpHeaderEncoder.DecodeValue("SGVsbG8="); + Assert.Equal("SGVsbG8=", result); + } + + [Fact] + public void DecodeValue_MissingSuffix_ReturnsLiteralValue() + { + var result = McpHeaderEncoder.DecodeValue("=?base64?SGVsbG8="); + Assert.Equal("=?base64?SGVsbG8=", result); + } + + [Theory] + [InlineData("us-west1")] + [InlineData("Hello, 世界")] + [InlineData(" padded ")] + [InlineData("line1\nline2")] + [InlineData("\tindented")] + [InlineData("a\tb")] + public void RoundTrip_EncodeDecode_PreservesValue(string original) + { + var encoded = McpHeaderEncoder.EncodeValue(original); + Assert.NotNull(encoded); + + var decoded = McpHeaderEncoder.DecodeValue(encoded); + Assert.Equal(original, decoded); + } + + [Fact] + public void EncodeValue_EmbeddedTab_Base64Encodes() + { + var result = McpHeaderEncoder.EncodeValue("col1\tcol2"); + Assert.StartsWith("=?base64?", result); + Assert.EndsWith("?=", result); + + // Verify round-trip + var decoded = McpHeaderEncoder.DecodeValue(result); + Assert.Equal("col1\tcol2", decoded); + } + + [Theory] + [InlineData("=?base64?literal?=")] + [InlineData("=?base64?SGVsbG8=?=")] + [InlineData("=?base64??=")] + public void EncodeValue_SentinelCollision_Base64Encodes(string input) + { + var result = McpHeaderEncoder.EncodeValue(input); + Assert.NotNull(result); + Assert.StartsWith("=?base64?", result); + Assert.EndsWith("?=", result); + + // The encoded value must be different from the input to avoid ambiguity + Assert.NotEqual(input, result); + + // Verify round-trip: decode must recover the original literal value + var decoded = McpHeaderEncoder.DecodeValue(result); + Assert.Equal(input, decoded); + } + + [Theory] + [InlineData("=?BASE64?literal?=")] // Case-sensitive: uppercase prefix does not match sentinel + [InlineData("=?base64?start")] // Missing suffix: no sentinel match + [InlineData("end?=")] // Missing prefix: no sentinel match + [InlineData("plain-text")] // No sentinel pattern + public void EncodeValue_NonSentinelPattern_NotBase64Encoded(string input) + { + var result = McpHeaderEncoder.EncodeValue(input); + Assert.Equal(input, result); + } +} diff --git a/tests/ModelContextProtocol.Tests/Client/McpHeaderExtractorValidationTests.cs b/tests/ModelContextProtocol.Tests/Client/McpHeaderExtractorValidationTests.cs new file mode 100644 index 000000000..ff3916d2a --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Client/McpHeaderExtractorValidationTests.cs @@ -0,0 +1,218 @@ +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.Text.Json; + +namespace ModelContextProtocol.Tests.Client; + +/// +/// Tests for SEP-2243 x-mcp-header validation changes: +/// - RFC 9110 tchar validation for header names +/// - "number" type rejection (only integer/string/boolean allowed) +/// - Nested property support for x-mcp-header annotations +/// +public class McpHeaderExtractorValidationTests : ClientServerTestBase +{ + public McpHeaderExtractorValidationTests(ITestOutputHelper outputHelper) + : base(outputHelper) + { + } + + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + // Valid baseline tool + mcpServerBuilder.WithTools([McpServerTool.Create( + (string input) => $"echo {input}", + new() { Name = "ValidTool" })]); + + // Tool with "number" type (should be rejected per updated SEP-2243) + var numberTool = McpServerTool.Create((string x) => x, new() { Name = "NumberTypeTool" }); + numberTool.ProtocolTool.InputSchema = JsonDocument.Parse(""" + { "type": "object", "properties": { "value": { "type": "number", "x-mcp-header": "Value" } } } + """).RootElement.Clone(); + mcpServerBuilder.WithTools([numberTool]); + + // Tool with "integer" type (should be accepted) + var integerTool = McpServerTool.Create((string x) => x, new() { Name = "IntegerTypeTool" }); + integerTool.ProtocolTool.InputSchema = JsonDocument.Parse(""" + { "type": "object", "properties": { "count": { "type": "integer", "x-mcp-header": "Count" } } } + """).RootElement.Clone(); + mcpServerBuilder.WithTools([integerTool]); + + // Tool with non-tchar header name (should be rejected) + var nonTcharTool = McpServerTool.Create((string x) => x, new() { Name = "BadTcharTool" }); + nonTcharTool.ProtocolTool.InputSchema = JsonDocument.Parse(""" + { "type": "object", "properties": { "region": { "type": "string", "x-mcp-header": "Region(1)" } } } + """).RootElement.Clone(); + mcpServerBuilder.WithTools([nonTcharTool]); + + // Tool with valid nested x-mcp-header + var nestedValidTool = McpServerTool.Create((string x) => x, new() { Name = "NestedValidTool" }); + nestedValidTool.ProtocolTool.InputSchema = JsonDocument.Parse(""" + { "type": "object", "properties": { "config": { "type": "object", "properties": { "region": { "type": "string", "x-mcp-header": "Region" } } } } } + """).RootElement.Clone(); + mcpServerBuilder.WithTools([nestedValidTool]); + + // Tool with invalid nested x-mcp-header (colon in header name) + var nestedInvalidTool = McpServerTool.Create((string x) => x, new() { Name = "NestedInvalidTool" }); + nestedInvalidTool.ProtocolTool.InputSchema = JsonDocument.Parse(""" + { "type": "object", "properties": { "config": { "type": "object", "properties": { "region": { "type": "string", "x-mcp-header": "Invalid:Header" } } } } } + """).RootElement.Clone(); + mcpServerBuilder.WithTools([nestedInvalidTool]); + + // Tool with duplicate header names across nesting levels + var duplicateTool = McpServerTool.Create((string x) => x, new() { Name = "DuplicateHeaderTool" }); + duplicateTool.ProtocolTool.InputSchema = JsonDocument.Parse(""" + { "type": "object", "properties": { "topRegion": { "type": "string", "x-mcp-header": "Region" }, "nested": { "type": "object", "properties": { "innerRegion": { "type": "string", "x-mcp-header": "region" } } } } } + """).RootElement.Clone(); + mcpServerBuilder.WithTools([duplicateTool]); + + // Tool with nested "number" type (should be rejected) + var nestedNumberTool = McpServerTool.Create((string x) => x, new() { Name = "NestedNumberTool" }); + nestedNumberTool.ProtocolTool.InputSchema = JsonDocument.Parse(""" + { "type": "object", "properties": { "config": { "type": "object", "properties": { "threshold": { "type": "number", "x-mcp-header": "Threshold" } } } } } + """).RootElement.Clone(); + mcpServerBuilder.WithTools([nestedNumberTool]); + + // Tool with a nullable union type ["string", "null"] (should be accepted) + var nullableUnionTool = McpServerTool.Create((string x) => x, new() { Name = "NullableUnionTool" }); + nullableUnionTool.ProtocolTool.InputSchema = JsonDocument.Parse(""" + { "type": "object", "properties": { "region": { "type": ["string", "null"], "x-mcp-header": "Region" } } } + """).RootElement.Clone(); + mcpServerBuilder.WithTools([nullableUnionTool]); + + // Tool with a union type containing a disallowed type ["number", "null"] (should be rejected) + var numberUnionTool = McpServerTool.Create((string x) => x, new() { Name = "NumberUnionTool" }); + numberUnionTool.ProtocolTool.InputSchema = JsonDocument.Parse(""" + { "type": "object", "properties": { "value": { "type": ["number", "null"], "x-mcp-header": "Value" } } } + """).RootElement.Clone(); + mcpServerBuilder.WithTools([numberUnionTool]); + + // Tool with a "null"-only union type (should be rejected: no allowed primitive present) + var nullOnlyTool = McpServerTool.Create((string x) => x, new() { Name = "NullOnlyTool" }); + nullOnlyTool.ProtocolTool.InputSchema = JsonDocument.Parse(""" + { "type": "object", "properties": { "value": { "type": ["null"], "x-mcp-header": "Value" } } } + """).RootElement.Clone(); + mcpServerBuilder.WithTools([nullOnlyTool]); + + // Tool whose annotated property omits "type" (should be accepted: type is unknown, not invalid) + var missingTypeTool = McpServerTool.Create((string x) => x, new() { Name = "MissingTypeTool" }); + missingTypeTool.ProtocolTool.InputSchema = JsonDocument.Parse(""" + { "type": "object", "properties": { "region": { "x-mcp-header": "Region" } } } + """).RootElement.Clone(); + mcpServerBuilder.WithTools([missingTypeTool]); + } + + [Fact] + public async Task ListToolsAsync_NumberType_ExcludesTool() + { + await using var client = await CreateMcpClientForServer(); + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + Assert.Contains(tools, t => t.Name == "ValidTool"); + Assert.DoesNotContain(tools, t => t.Name == "NumberTypeTool"); + + Assert.Contains(MockLoggerProvider.LogMessages, log => + log.LogLevel == LogLevel.Warning && + log.Message.Contains("NumberTypeTool") && + log.Message.Contains("excluded")); + } + + [Fact] + public async Task ListToolsAsync_IntegerType_AcceptsTool() + { + await using var client = await CreateMcpClientForServer(); + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + Assert.Contains(tools, t => t.Name == "IntegerTypeTool"); + } + + [Fact] + public async Task ListToolsAsync_NonTcharHeaderName_ExcludesTool() + { + await using var client = await CreateMcpClientForServer(); + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + Assert.Contains(tools, t => t.Name == "ValidTool"); + Assert.DoesNotContain(tools, t => t.Name == "BadTcharTool"); + } + + [Fact] + public async Task ListToolsAsync_NestedValidHeader_AcceptsTool() + { + await using var client = await CreateMcpClientForServer(); + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + Assert.Contains(tools, t => t.Name == "NestedValidTool"); + } + + [Fact] + public async Task ListToolsAsync_NestedInvalidHeader_ExcludesTool() + { + await using var client = await CreateMcpClientForServer(); + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + Assert.Contains(tools, t => t.Name == "ValidTool"); + Assert.DoesNotContain(tools, t => t.Name == "NestedInvalidTool"); + } + + [Fact] + public async Task ListToolsAsync_NestedDuplicateHeaders_ExcludesTool() + { + await using var client = await CreateMcpClientForServer(); + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + Assert.Contains(tools, t => t.Name == "ValidTool"); + Assert.DoesNotContain(tools, t => t.Name == "DuplicateHeaderTool"); + } + + [Fact] + public async Task ListToolsAsync_NestedNumberType_ExcludesTool() + { + await using var client = await CreateMcpClientForServer(); + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + Assert.Contains(tools, t => t.Name == "ValidTool"); + Assert.DoesNotContain(tools, t => t.Name == "NestedNumberTool"); + } + + [Fact] + public async Task ListToolsAsync_NullableUnionType_AcceptsTool() + { + await using var client = await CreateMcpClientForServer(); + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + Assert.Contains(tools, t => t.Name == "NullableUnionTool"); + } + + [Fact] + public async Task ListToolsAsync_NumberUnionType_ExcludesTool() + { + await using var client = await CreateMcpClientForServer(); + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + Assert.Contains(tools, t => t.Name == "ValidTool"); + Assert.DoesNotContain(tools, t => t.Name == "NumberUnionTool"); + } + + [Fact] + public async Task ListToolsAsync_NullOnlyUnionType_ExcludesTool() + { + await using var client = await CreateMcpClientForServer(); + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + Assert.Contains(tools, t => t.Name == "ValidTool"); + Assert.DoesNotContain(tools, t => t.Name == "NullOnlyTool"); + } + + [Fact] + public async Task ListToolsAsync_MissingType_AcceptsTool() + { + await using var client = await CreateMcpClientForServer(); + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + Assert.Contains(tools, t => t.Name == "MissingTypeTool"); + } +} diff --git a/tests/ModelContextProtocol.Tests/Client/McpRequestHeadersTests.cs b/tests/ModelContextProtocol.Tests/Client/McpRequestHeadersTests.cs new file mode 100644 index 000000000..be629ecd2 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Client/McpRequestHeadersTests.cs @@ -0,0 +1,36 @@ +using ModelContextProtocol.Protocol; + +namespace ModelContextProtocol.Tests.Client; + +public class McpRequestHeadersTests +{ + [Fact] + public void McpHttpHeaders_HasCorrectValues() + { + Assert.Equal("Mcp-Session-Id", McpHttpHeaders.SessionId); + Assert.Equal("MCP-Protocol-Version", McpHttpHeaders.ProtocolVersion); + Assert.Equal("Last-Event-ID", McpHttpHeaders.LastEventId); + Assert.Equal("Mcp-Method", McpHttpHeaders.Method); + Assert.Equal("Mcp-Name", McpHttpHeaders.Name); + Assert.Equal("Mcp-Param-", McpHttpHeaders.ParamPrefix); + } + + [Fact] + public void McpErrorCode_HeaderMismatch_HasCorrectValue() + { + Assert.Equal(-32020, (int)McpErrorCode.HeaderMismatch); + } + + [Theory] + [InlineData("2026-07-28", true)] + [InlineData("2025-11-25", false)] + [InlineData("2025-06-18", false)] + [InlineData("2024-11-05", false)] + [InlineData(null, false)] + [InlineData("", false)] + public void RequiresStandardHeaders_ReturnsExpected(string? version, bool expected) + { + Assert.Equal(expected, McpProtocolVersions.RequiresStandardHeaders(version)); + } + +} diff --git a/tests/ModelContextProtocol.Tests/Client/MrtrIntegrationTests.cs b/tests/ModelContextProtocol.Tests/Client/MrtrIntegrationTests.cs new file mode 100644 index 000000000..86a107fd9 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Client/MrtrIntegrationTests.cs @@ -0,0 +1,573 @@ +#if !NET472 +using Microsoft.Extensions.AI; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using ModelContextProtocol.Tests.Utils; +using System.IO.Pipelines; +using System.Text.Json; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.Tests.Client; + +/// +/// Edge-case and guardrail tests for MRTR over in-memory pipe transport. These focus on +/// scenarios not easily covered by +/// which provides broad happy-path coverage across StreamableHttp, SSE, and Stateless transports. +/// +public class MrtrIntegrationTests : ClientServerTestBase +{ + private readonly ServerMessageTracker _messageTracker = new(); + + public MrtrIntegrationTests(ITestOutputHelper testOutputHelper) + : base(testOutputHelper, startServer: false) + { + } + + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + services.AddLogging(builder => builder.SetMinimumLevel(LogLevel.Debug)); + services.Configure(options => + { + options.ProtocolVersion = "2026-07-28"; + _messageTracker.AddFilters(options.Filters.Message); + }); + + mcpServerBuilder.WithTools([ + McpServerTool.Create( + async (string message, McpServer server, CancellationToken ct) => + { + var result = await server.ElicitAsync(new ElicitRequestParams + { + Message = message, + RequestedSchema = new() + }, ct); + + return $"{result.Action}:{result.Content?.FirstOrDefault().Value}"; + }, + new McpServerToolCreateOptions + { + Name = "elicitation-tool", + Description = "A tool that requests elicitation from the client" + }), + McpServerTool.Create( + async (McpServer server) => + { + // Attempt to send a JsonRpcRequest via SendMessageAsync - should always throw + // since requests must go through SendRequestAsync for response correlation. + try + { + await server.SendMessageAsync(new JsonRpcRequest + { + Id = new RequestId(999), + Method = RequestMethods.ElicitationCreate, + Params = JsonSerializer.SerializeToNode(new ElicitRequestParams + { + Message = "Bypass attempt", + RequestedSchema = new() + }, McpJsonUtilities.DefaultOptions) + }); + return "NOT BLOCKED - expected InvalidOperationException"; + } + catch (InvalidOperationException ex) + { + return $"blocked:{ex.Message}"; + } + }, + new McpServerToolCreateOptions + { + Name = "sendmessage-bypass-tool", + Description = "A tool that attempts to bypass MRTR via SendMessageAsync" + }) + ]); + } + + [Fact] + public async Task ClientHandlerException_DuringMrtrInputResolution_SurfacesToCaller() + { + // When the CLIENT's elicitation handler throws during MRTR input resolution, + // the retry never reaches the server - the server's handler remains suspended + // on ElicitAsync(). The exception should surface to the CallToolAsync caller, + // and the server's orphaned handler should be cleaned up on disposal. + // This is a fundamental MRTR limitation: the client has no channel to communicate + // input resolution failures back to the server. + StartServer(); + + var clientOptions = new McpClientOptions { ProtocolVersion = "2026-07-28" }; + clientOptions.Handlers.ElicitationHandler = (request, ct) => + { + throw new InvalidOperationException("Client-side elicitation failure"); + }; + + await using var client = await CreateMcpClientForServer(clientOptions); + Assert.Equal("2026-07-28", client.NegotiatedProtocolVersion); + + // The client handler throws during input resolution, so the exception + // escapes ResolveInputRequestAsync and surfaces directly to the caller. + var ex = await Assert.ThrowsAsync(async () => + await client.CallToolAsync("elicitation-tool", + new Dictionary { ["message"] = "Will fail" }, + cancellationToken: TestContext.Current.CancellationToken)); + + Assert.Equal("Client-side elicitation failure", ex.Message); + + // Dispose the server to trigger cleanup of the orphaned MRTR continuation. + // The server should cancel the handler suspended on ElicitAsync() and log + // the cancelled continuation at Debug level. + await Server.DisposeAsync(); + + Assert.Contains(MockLoggerProvider.LogMessages, m => + m.LogLevel == LogLevel.Debug && + m.Message.Contains("Cancelled") && + m.Message.Contains("MRTR continuation")); + } + + [Fact] + public async Task SendMessageAsync_WithJsonRpcRequest_ThrowsAlways() + { + // SendMessageAsync should throw InvalidOperationException if the message is a + // JsonRpcRequest, regardless of MRTR state. Use SendRequestAsync for requests. + StartServer(); + var clientOptions = new McpClientOptions { ProtocolVersion = "2026-07-28" }; + clientOptions.Handlers.ElicitationHandler = (request, ct) => + new ValueTask(new ElicitResult { Action = "accept" }); + + await using var client = await CreateMcpClientForServer(clientOptions); + + var result = await client.CallToolAsync("sendmessage-bypass-tool", + cancellationToken: TestContext.Current.CancellationToken); + + var text = Assert.IsType(Assert.Single(result.Content)).Text; + Assert.StartsWith("blocked:", text); + Assert.Contains("SendMessageAsync", text); + Assert.Contains("SendRequestAsync", text); + } + + [Fact] + public async Task LegacyRequestOnMrtrSession_LogsWarning() + { + // This test simulates a non-compliant server that negotiates MRTR + // but sends legacy elicitation/create JSON-RPC requests instead of + // using InputRequiredResult. The client should handle it but log a warning. + StartServer(); // Required for base class DisposeAsync cleanup + var clientToServer = new Pipe(); + var serverToClient = new Pipe(); + + var clientOptions = new McpClientOptions { ProtocolVersion = "2026-07-28" }; + clientOptions.Handlers.ElicitationHandler = (request, ct) => + new ValueTask(new ElicitResult { Action = "accept" }); + clientOptions.Handlers.SamplingHandler = (request, progress, ct) => + new ValueTask(new CreateMessageResult + { + Content = [new TextContentBlock { Text = "sampled" }], + Model = "test-model" + }); + + // Start the client task. It will send server/discover (2026-07-28 protocol) and block waiting for response + var clientTask = McpClient.CreateAsync( + new StreamClientTransport( + clientToServer.Writer.AsStream(), + serverToClient.Reader.AsStream(), + LoggerFactory), + clientOptions, + loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken); + + // Simulate server: read server/discover request, respond with a DiscoverResult + // that advertises support for the experimental version. + var serverReader = new StreamReader(clientToServer.Reader.AsStream()); + var serverWriter = serverToClient.Writer.AsStream(); + + // Read the server/discover request from client (the 2026-07-28 protocol skips initialize per SEP-2575). + var discoverLine = await serverReader.ReadLineAsync(TestContext.Current.CancellationToken); + Assert.NotNull(discoverLine); + var discoverRequest = JsonSerializer.Deserialize(discoverLine, McpJsonUtilities.DefaultOptions); + Assert.NotNull(discoverRequest); + Assert.Equal(RequestMethods.ServerDiscover, discoverRequest.Method); + + // Respond with a DiscoverResult that includes the experimental version in supportedVersions. + var discoverResponse = new JsonRpcResponse + { + Id = discoverRequest.Id, + Result = JsonSerializer.SerializeToNode(new DiscoverResult + { + SupportedVersions = new List { "2026-07-28" }, + Capabilities = new ServerCapabilities(), + Meta = new JsonObject + { + [MetaKeys.ServerInfo] = JsonSerializer.SerializeToNode(new Implementation { Name = "MockMrtrServer", Version = "1.0" }, McpJsonUtilities.DefaultOptions), + }, + }, McpJsonUtilities.DefaultOptions), + }; + await WriteJsonRpcAsync(serverWriter, discoverResponse); + + // Client is now connected with MRTR negotiated (no initialized notification under the 2026-07-28 protocol). + await using var client = await clientTask; + Assert.Equal("2026-07-28", client.NegotiatedProtocolVersion); + + // Now simulate the non-compliant server sending a legacy elicitation/create request + var legacyRequest = new JsonRpcRequest + { + Id = new RequestId(42), + Method = RequestMethods.ElicitationCreate, + Params = JsonSerializer.SerializeToNode(new ElicitRequestParams + { + Message = "Legacy elicitation from non-compliant server", + RequestedSchema = new() + }, McpJsonUtilities.DefaultOptions), + }; + await WriteJsonRpcAsync(serverWriter, legacyRequest); + + // Read the client's response to the legacy request + var responseLine = await serverReader.ReadLineAsync(TestContext.Current.CancellationToken); + Assert.NotNull(responseLine); + var clientResponse = JsonSerializer.Deserialize(responseLine, McpJsonUtilities.DefaultOptions); + Assert.NotNull(clientResponse); + Assert.Equal(new RequestId(42), clientResponse.Id); + + // Verify the client handled the request (returned ElicitResult) + var elicitResult = JsonSerializer.Deserialize(clientResponse.Result, McpJsonUtilities.DefaultOptions); + Assert.NotNull(elicitResult); + Assert.Equal("accept", elicitResult.Action); + + // Verify the warning was logged + Assert.Contains(MockLoggerProvider.LogMessages, m => + m.LogLevel == LogLevel.Warning && + m.Message.Contains("elicitation/create") && + m.Message.Contains("MRTR")); + + // Clean up + clientToServer.Writer.Complete(); + serverToClient.Writer.Complete(); + } + + [Fact] + public async Task IncompleteResultOnNonMrtrSession_LogsWarning() + { + // This test simulates a non-compliant server that sends an InputRequiredResult + // to a client that did NOT negotiate MRTR. The client should still process it + // (resilience), but log a warning about the unexpected protocol behavior. + StartServer(); // Required for base class DisposeAsync cleanup + var clientToServer = new Pipe(); + var serverToClient = new Pipe(); + + // Client is pinned to a legacy protocol version, so it performs the initialize + // handshake and the session is treated as non-MRTR. + var clientOptions = new McpClientOptions { ProtocolVersion = "2025-03-26" }; + clientOptions.Handlers.ElicitationHandler = (request, ct) => + new ValueTask(new ElicitResult + { + Action = "accept", + Content = new Dictionary + { + ["confirmed"] = JsonDocument.Parse("\"yes\"").RootElement.Clone() + } + }); + + // Start the client task - it will send initialize and block waiting for response + var clientTask = McpClient.CreateAsync( + new StreamClientTransport( + clientToServer.Writer.AsStream(), + serverToClient.Reader.AsStream(), + LoggerFactory), + clientOptions, + loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken); + + var serverReader = new StreamReader(clientToServer.Reader.AsStream()); + var serverWriter = serverToClient.Writer.AsStream(); + + // Read the initialize request from client + var initLine = await serverReader.ReadLineAsync(TestContext.Current.CancellationToken); + Assert.NotNull(initLine); + var initRequest = JsonSerializer.Deserialize(initLine, McpJsonUtilities.DefaultOptions); + Assert.NotNull(initRequest); + Assert.Equal("initialize", initRequest.Method); + + // Respond with standard protocol version (no MRTR) + var initResponse = new JsonRpcResponse + { + Id = initRequest.Id, + Result = JsonSerializer.SerializeToNode(new InitializeResult + { + ProtocolVersion = "2025-03-26", + Capabilities = new ServerCapabilities { Tools = new() }, + ServerInfo = new Implementation { Name = "NonCompliantServer", Version = "1.0" } + }, McpJsonUtilities.DefaultOptions), + }; + await WriteJsonRpcAsync(serverWriter, initResponse); + + // Read the initialized notification from client + var initializedLine = await serverReader.ReadLineAsync(TestContext.Current.CancellationToken); + Assert.NotNull(initializedLine); + + // Client is now connected with standard protocol (no MRTR) + await using var client = await clientTask; + Assert.Equal("2025-03-26", client.NegotiatedProtocolVersion); + + // Start a background task to handle the client's tools/call request + var cancellationToken = TestContext.Current.CancellationToken; + var serverLoop = Task.Run(async () => + { + // Read tools/call request from client + var callLine = await serverReader.ReadLineAsync(cancellationToken); + Assert.NotNull(callLine); + var callRequest = JsonSerializer.Deserialize(callLine, McpJsonUtilities.DefaultOptions); + Assert.NotNull(callRequest); + Assert.Equal("tools/call", callRequest.Method); + + // Non-compliant server sends InputRequiredResult on standard protocol session! + var InputRequiredResult = new JsonObject + { + ["resultType"] = "input_required", + ["inputRequests"] = new JsonObject + { + ["confirm_1"] = JsonSerializer.SerializeToNode( + InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "Unexpected elicitation from non-compliant server", + RequestedSchema = new() + }), McpJsonUtilities.DefaultOptions) + }, + ["requestState"] = "non-mrtr-state" + }; + + var incompleteResponse = new JsonRpcResponse + { + Id = callRequest.Id, + Result = InputRequiredResult, + }; + await WriteJsonRpcAsync(serverWriter, incompleteResponse); + + // Read the retry request with inputResponses from client + var retryLine = await serverReader.ReadLineAsync(cancellationToken); + Assert.NotNull(retryLine); + var retryRequest = JsonSerializer.Deserialize(retryLine, McpJsonUtilities.DefaultOptions); + Assert.NotNull(retryRequest); + Assert.Equal("tools/call", retryRequest.Method); + + // Verify the retry contains inputResponses and requestState + var retryParams = retryRequest.Params as JsonObject; + Assert.NotNull(retryParams); + Assert.NotNull(retryParams["inputResponses"]); + Assert.Equal("non-mrtr-state", retryParams["requestState"]?.GetValue()); + + // Now respond with a normal result + var normalResult = new JsonRpcResponse + { + Id = retryRequest.Id, + Result = JsonSerializer.SerializeToNode(new CallToolResult + { + Content = [new TextContentBlock { Text = "completed-without-mrtr" }] + }, McpJsonUtilities.DefaultOptions), + }; + await WriteJsonRpcAsync(serverWriter, normalResult); + }, cancellationToken); + + // Client calls the tool - the non-compliant server will send InputRequiredResult + var response = await client.SendRequestAsync( + new JsonRpcRequest + { + Method = "tools/call", + Params = JsonSerializer.SerializeToNode(new CallToolRequestParams + { + Name = "any-tool", + }, McpJsonUtilities.DefaultOptions) + }, + cancellationToken); + + await serverLoop; + + Assert.NotNull(response.Result); + var result = JsonSerializer.Deserialize(response.Result, McpJsonUtilities.DefaultOptions); + Assert.NotNull(result); + var content = Assert.Single(result.Content); + Assert.Equal("completed-without-mrtr", Assert.IsType(content).Text); + + // Verify the warning was logged about InputRequiredResult on non-MRTR session + Assert.Contains(MockLoggerProvider.LogMessages, m => + m.LogLevel == LogLevel.Warning && + m.Message.Contains("InputRequiredResult") && + m.Message.Contains("did not negotiate MRTR")); + + // Clean up + clientToServer.Writer.Complete(); + serverToClient.Writer.Complete(); + } + + [Fact] + public async Task IncompleteResultRetry_OmittingRequestState_StripsStaleStateFromRetryParams() + { + // Regression test for #1458 review feedback: when the server returns InputRequiredResult + // with requestState on round 1 and then InputRequiredResult WITHOUT requestState on round 2, + // the client's third retry must NOT carry the stale round-1 requestState forward via the + // params deep clone. Without the fix, the third retry's params contain {"requestState": "round1-state"} + // even though the round-2 InputRequiredResult cleared it. + StartServer(); // base-class disposal hook + var clientToServer = new Pipe(); + var serverToClient = new Pipe(); + + // Pin to the 2026-07-28 protocol so the client performs the server/discover handshake and + // treats InputRequiredResult as an MRTR round-trip. + var clientOptions = new McpClientOptions { ProtocolVersion = "2026-07-28" }; + clientOptions.Handlers.ElicitationHandler = (_, _) => + new ValueTask(new ElicitResult + { + Action = "accept", + Content = new Dictionary + { + ["confirmed"] = JsonDocument.Parse("\"yes\"").RootElement.Clone() + } + }); + + var clientTask = McpClient.CreateAsync( + new StreamClientTransport( + clientToServer.Writer.AsStream(), + serverToClient.Reader.AsStream(), + LoggerFactory), + clientOptions, + loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken); + + var serverReader = new StreamReader(clientToServer.Reader.AsStream()); + var serverWriter = serverToClient.Writer.AsStream(); + + // server/discover handshake - negotiate 2026-07-28 so the client treats InputRequiredResult as MRTR. + var discoverLine = await serverReader.ReadLineAsync(TestContext.Current.CancellationToken); + Assert.NotNull(discoverLine); + var discoverRequest = JsonSerializer.Deserialize(discoverLine, McpJsonUtilities.DefaultOptions); + Assert.NotNull(discoverRequest); + Assert.Equal("server/discover", discoverRequest.Method); + + var discoverResponse = new JsonRpcResponse + { + Id = discoverRequest.Id, + Result = JsonSerializer.SerializeToNode(new DiscoverResult + { + SupportedVersions = ["2026-07-28"], + Capabilities = new ServerCapabilities { Tools = new() }, + Meta = new JsonObject + { + [MetaKeys.ServerInfo] = JsonSerializer.SerializeToNode(new Implementation { Name = "MrtrServer", Version = "1.0" }, McpJsonUtilities.DefaultOptions), + }, + }, McpJsonUtilities.DefaultOptions), + }; + await WriteJsonRpcAsync(serverWriter, discoverResponse); + + await using var client = await clientTask; + Assert.Equal("2026-07-28", client.NegotiatedProtocolVersion); + + var cancellationToken = TestContext.Current.CancellationToken; + + // Capture the retry payloads sent by the client so we can inspect them after the call completes. + JsonObject? retry1Params = null; + JsonObject? retry2Params = null; + + var serverLoop = Task.Run(async () => + { + // --- Round 1: receive original tools/call, respond with InputRequiredResult + requestState="round1-state". + var call1Line = await serverReader.ReadLineAsync(cancellationToken); + Assert.NotNull(call1Line); + var call1 = JsonSerializer.Deserialize(call1Line, McpJsonUtilities.DefaultOptions); + Assert.NotNull(call1); + Assert.Equal("tools/call", call1.Method); + + var round1Result = new JsonObject + { + ["resultType"] = "input_required", + ["inputRequests"] = new JsonObject + { + ["q1"] = JsonSerializer.SerializeToNode( + InputRequest.ForElicitation(new ElicitRequestParams { Message = "round1", RequestedSchema = new() }), + McpJsonUtilities.DefaultOptions), + }, + ["requestState"] = "round1-state", + }; + await WriteJsonRpcAsync(serverWriter, new JsonRpcResponse { Id = call1.Id, Result = round1Result }); + + // --- Round 2: receive first retry (should include requestState="round1-state" + inputResponses). + var call2Line = await serverReader.ReadLineAsync(cancellationToken); + Assert.NotNull(call2Line); + var call2 = JsonSerializer.Deserialize(call2Line, McpJsonUtilities.DefaultOptions); + Assert.NotNull(call2); + retry1Params = call2.Params as JsonObject; + + // Respond with another InputRequiredResult - this time WITHOUT requestState - to force the + // client to clear any stale state on the next retry params clone. + var round2Result = new JsonObject + { + ["resultType"] = "input_required", + ["inputRequests"] = new JsonObject + { + ["q2"] = JsonSerializer.SerializeToNode( + InputRequest.ForElicitation(new ElicitRequestParams { Message = "round2", RequestedSchema = new() }), + McpJsonUtilities.DefaultOptions), + }, + // Intentionally NO "requestState" key. + }; + await WriteJsonRpcAsync(serverWriter, new JsonRpcResponse { Id = call2.Id, Result = round2Result }); + + // --- Round 3: receive second retry - assertion target. Must NOT contain "requestState". + var call3Line = await serverReader.ReadLineAsync(cancellationToken); + Assert.NotNull(call3Line); + var call3 = JsonSerializer.Deserialize(call3Line, McpJsonUtilities.DefaultOptions); + Assert.NotNull(call3); + retry2Params = call3.Params as JsonObject; + + // Final success response so the client's call completes cleanly. + await WriteJsonRpcAsync(serverWriter, new JsonRpcResponse + { + Id = call3.Id, + Result = JsonSerializer.SerializeToNode(new CallToolResult + { + Content = [new TextContentBlock { Text = "done" }] + }, McpJsonUtilities.DefaultOptions), + }); + }, cancellationToken); + + var response = await client.SendRequestAsync( + new JsonRpcRequest + { + Method = "tools/call", + Params = JsonSerializer.SerializeToNode(new CallToolRequestParams { Name = "any-tool" }, McpJsonUtilities.DefaultOptions), + }, + cancellationToken); + + await serverLoop; + + // Sanity check the final result reached us. + Assert.NotNull(response.Result); + var result = JsonSerializer.Deserialize(response.Result, McpJsonUtilities.DefaultOptions); + Assert.NotNull(result); + Assert.Equal("done", Assert.IsType(Assert.Single(result.Content)).Text); + + // The first retry must carry requestState="round1-state". + Assert.NotNull(retry1Params); + Assert.NotNull(retry1Params!["inputResponses"]); + Assert.Equal("round1-state", retry1Params["requestState"]?.GetValue()); + + // The second retry must NOT carry a stale requestState. Pre-fix, the deep clone of the + // round-1 request kept "round1-state" in paramsObj because the client only OVERWROTE it + // when InputRequiredResult.RequestState was non-null. With the fix, it explicitly removes + // the key whenever the server's new InputRequiredResult clears it. + Assert.NotNull(retry2Params); + Assert.NotNull(retry2Params!["inputResponses"]); + Assert.False(retry2Params.ContainsKey("requestState"), + "Retry params must not carry a stale requestState from the previous round."); + + clientToServer.Writer.Complete(); + serverToClient.Writer.Complete(); + } + + private static async Task WriteJsonRpcAsync(Stream writer, JsonRpcMessage message) + { + var bytes = JsonSerializer.SerializeToUtf8Bytes(message, McpJsonUtilities.DefaultOptions); + await writer.WriteAsync(bytes, TestContext.Current.CancellationToken); + await writer.WriteAsync("\n"u8.ToArray(), TestContext.Current.CancellationToken); + await writer.FlushAsync(TestContext.Current.CancellationToken); + } +} + +#endif diff --git a/tests/ModelContextProtocol.Tests/ClientIntegrationTestFixture.cs b/tests/ModelContextProtocol.Tests/ClientIntegrationTestFixture.cs index 6f0e8e44a..726a3fb1a 100644 --- a/tests/ModelContextProtocol.Tests/ClientIntegrationTestFixture.cs +++ b/tests/ModelContextProtocol.Tests/ClientIntegrationTestFixture.cs @@ -16,6 +16,8 @@ public class ClientIntegrationTestFixture public ClientIntegrationTestFixture() { const string ServerEverythingVersion = "2026.1.26"; + string testServerExecutable = Path.Combine(AppContext.BaseDirectory, "TestServer.exe"); + string testServerDll = Path.Combine(AppContext.BaseDirectory, "TestServer.dll"); EverythingServerTransportOptions = new() { @@ -27,14 +29,14 @@ public ClientIntegrationTestFixture() TestServerTransportOptions = new() { - Command = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "TestServer.exe" : PlatformDetection.IsMonoRuntime ? "mono" : "dotnet", + Command = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? testServerExecutable : PlatformDetection.IsMonoRuntime ? "mono" : "dotnet", Name = "TestServer", }; if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { // Change to Arguments to "mcp-server-everything" if you want to run the server locally after creating a symlink - TestServerTransportOptions.Arguments = [PlatformDetection.IsMonoRuntime ? "TestServer.exe" : "TestServer.dll"]; + TestServerTransportOptions.Arguments = [PlatformDetection.IsMonoRuntime ? testServerExecutable : testServerDll]; } } diff --git a/tests/ModelContextProtocol.Tests/ClientIntegrationTests.cs b/tests/ModelContextProtocol.Tests/ClientIntegrationTests.cs index 70553ee45..d01f40a6f 100644 --- a/tests/ModelContextProtocol.Tests/ClientIntegrationTests.cs +++ b/tests/ModelContextProtocol.Tests/ClientIntegrationTests.cs @@ -33,7 +33,10 @@ public async Task ConnectAndPing_Stdio(string clientId) // Arrange // Act - await using var client = await _fixture.CreateClientAsync(clientId); + // ping was removed in the 2026-07-28 protocol (SEP-2575), so pin to the latest + // initialize-handshake revision to keep exercising the ping RPC. The 2026-07-28 protocol + // relies on the transport/request lifecycle instead of an explicit ping. + await using var client = await _fixture.CreateClientAsync(clientId, new McpClientOptions { ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion }); await client.PingAsync(cancellationToken: TestContext.Current.CancellationToken); // Assert @@ -274,6 +277,7 @@ public async Task SubscribeResource_Stdio() TaskCompletionSource tcs = new(); await using var client = await _fixture.CreateClientAsync(clientId, new() { + ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion, Handlers = new() { NotificationHandlers = @@ -304,6 +308,7 @@ public async Task UnsubscribeResource_Stdio() TaskCompletionSource receivedNotification = new(); await using var client = await _fixture.CreateClientAsync(clientId, new() { + ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion, Handlers = new() { NotificationHandlers = @@ -555,6 +560,7 @@ public async Task SetLoggingLevel_ReceivesLoggingMessages(string clientId) TaskCompletionSource receivedNotification = new(); await using var client = await _fixture.CreateClientAsync(clientId, new() { + ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion, Handlers = new() { NotificationHandlers = @@ -723,6 +729,7 @@ public async Task SubscribeToResourceAsync_WithRequestParams_Succeeds() TaskCompletionSource tcs = new(); await using var client = await _fixture.CreateClientAsync(clientId, new() { + ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion, Handlers = new() { NotificationHandlers = @@ -752,6 +759,7 @@ public async Task UnsubscribeFromResourceAsync_WithRequestParams_Succeeds() TaskCompletionSource receivedNotification = new(); await using var client = await _fixture.CreateClientAsync(clientId, new() { + ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion, Handlers = new() { NotificationHandlers = diff --git a/tests/ModelContextProtocol.Tests/ClientServerTestBase.cs b/tests/ModelContextProtocol.Tests/ClientServerTestBase.cs index 564225abd..4e500b5ab 100644 --- a/tests/ModelContextProtocol.Tests/ClientServerTestBase.cs +++ b/tests/ModelContextProtocol.Tests/ClientServerTestBase.cs @@ -86,6 +86,12 @@ public async ValueTask DisposeAsync() protected async Task CreateMcpClientForServer(McpClientOptions? clientOptions = null) { + clientOptions ??= new McpClientOptions(); + + // Disable the server/discover probe timeout to avoid CI slowness spuriously tripping it (issue #1701). + // Tests that need a specific probe timeout should create their own client instead of using this helper. + clientOptions.DiscoverProbeTimeout = TestConstants.DefaultTimeout; + return await McpClient.CreateAsync( new StreamClientTransport( serverInput: _clientToServerPipe.Writer.AsStream(), diff --git a/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsHandlerTests.cs b/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsHandlerTests.cs index e61c442bf..be965e7b1 100644 --- a/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsHandlerTests.cs +++ b/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsHandlerTests.cs @@ -147,4 +147,17 @@ public void WithUnsubscribeFromResourcesHandler_Sets_Handler() Assert.Equal(handler, options.Handlers.UnsubscribeFromResourcesHandler); } + + [Fact] + public void WithSubscriptionsListenHandler_Sets_Handler() + { + McpRequestHandler handler = async (context, token) => new EmptyResult(); + + _builder.Object.WithSubscriptionsListenHandler(handler); + + var serviceProvider = _services.BuildServiceProvider(); + var options = serviceProvider.GetRequiredService>().Value; + + Assert.Equal(handler, options.Handlers.SubscriptionsListenHandler); + } } diff --git a/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsMessageFilterTests.cs b/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsMessageFilterTests.cs index 171c6bead..45cf0379c 100644 --- a/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsMessageFilterTests.cs +++ b/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsMessageFilterTests.cs @@ -11,6 +11,8 @@ namespace ModelContextProtocol.Tests.Configuration; public class McpServerBuilderExtensionsMessageFilterTests(ITestOutputHelper testOutputHelper) : ClientServerTestBase(testOutputHelper, startServer: false) { + private const string LatestStableVersion = "2025-11-25"; + private static ILogger GetLogger(IServiceProvider? services, string categoryName) { var loggerFactory = services?.GetRequiredService() ?? throw new InvalidOperationException("LoggerFactory not available"); @@ -72,12 +74,26 @@ public async Task AddIncomingMessageFilter_Intercepts_Request_Messages() { List messageTypes = []; + // Under the 2026-07-28 protocol the client performs a server/discover + tools/list exchange (no + // fire-and-forget initialized notification), so the tools/list request is a deterministic + // synchronization point. Gate recording to it and signal once the filter finishes so a + // regression that invokes the filter pipeline more than once per message surfaces as an extra entry. + var toolsListProcessed = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + McpServerBuilder .WithMessageFilters(filters => filters.AddIncomingFilter((next) => async (context, cancellationToken) => { - var messageTypeName = context.JsonRpcMessage.GetType().Name; - messageTypes.Add(messageTypeName); + if (context.JsonRpcMessage is JsonRpcRequest { Method: RequestMethods.ToolsList }) + { + messageTypes.Add(context.JsonRpcMessage.GetType().Name); + } + await next(context, cancellationToken); + + if (context.JsonRpcMessage is JsonRpcRequest { Method: RequestMethods.ToolsList }) + { + toolsListProcessed.TrySetResult(true); + } })) .WithTools(); @@ -87,30 +103,57 @@ public async Task AddIncomingMessageFilter_Intercepts_Request_Messages() await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); - // The message filter should intercept JsonRpcRequest messages - Assert.Contains("JsonRpcRequest", messageTypes); + await toolsListProcessed.Task.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); + + // The message filter should intercept the tools/list JsonRpcRequest exactly once. + Assert.Collection(messageTypes, m => Assert.Equal(nameof(JsonRpcRequest), m)); } [Fact] public async Task AddIncomingMessageFilter_Multiple_Filters_Execute_In_Order() { + // Under the 2026-07-28 protocol the client performs a server/discover + tools/list exchange (no + // fire-and-forget initialized notification), so the tools/list request is a deterministic + // synchronization point. Gate the filter logging to it and signal once the outermost filter + // finishes so the assertions observe a complete, stable log. + var toolsListProcessed = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + McpServerBuilder .WithMessageFilters(filters => { filters.AddIncomingFilter((next) => async (context, cancellationToken) => { + var isToolsList = context.JsonRpcMessage is JsonRpcRequest { Method: RequestMethods.ToolsList }; var logger = GetLogger(context.Services, "MessageFilter1"); - logger.LogInformation("MessageFilter1 before"); + if (isToolsList) + { + logger.LogInformation("MessageFilter1 before"); + } + await next(context, cancellationToken); - logger.LogInformation("MessageFilter1 after"); + + if (isToolsList) + { + logger.LogInformation("MessageFilter1 after"); + toolsListProcessed.TrySetResult(true); + } }); filters.AddIncomingFilter((next) => async (context, cancellationToken) => { + var isToolsList = context.JsonRpcMessage is JsonRpcRequest { Method: RequestMethods.ToolsList }; var logger = GetLogger(context.Services, "MessageFilter2"); - logger.LogInformation("MessageFilter2 before"); + if (isToolsList) + { + logger.LogInformation("MessageFilter2 before"); + } + await next(context, cancellationToken); - logger.LogInformation("MessageFilter2 after"); + + if (isToolsList) + { + logger.LogInformation("MessageFilter2 after"); + } }); }) .WithTools(); @@ -121,27 +164,23 @@ public async Task AddIncomingMessageFilter_Multiple_Filters_Execute_In_Order() await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + // Wait for the outermost filter to finish processing the tools/list request before + // snapshotting the log; otherwise the assertions can race the still-in-flight "after" logs. + await toolsListProcessed.Task.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); + var logMessages = MockLoggerProvider.LogMessages .Where(m => m.Category.StartsWith("MessageFilter")) .Select(m => m.Message) .ToList(); - // First filter registered is outermost - // We should see this pattern for each message: MessageFilter1 before -> MessageFilter2 before -> MessageFilter2 after -> MessageFilter1 after - int idx1Before = logMessages.IndexOf("MessageFilter1 before"); - int idx2Before = logMessages.IndexOf("MessageFilter2 before"); - int idx2After = logMessages.IndexOf("MessageFilter2 after"); - int idx1After = logMessages.IndexOf("MessageFilter1 after"); - - Assert.True(idx1Before >= 0); - Assert.True(idx2Before >= 0); - Assert.True(idx2After >= 0); - Assert.True(idx1After >= 0); - - // Verify ordering within a single request - Assert.True(idx1Before < idx2Before); - Assert.True(idx2Before < idx2After); - Assert.True(idx2After < idx1After); + // First filter registered is outermost. For the single gated tools/list request we expect the + // strict nested order. Assert.Collection also catches any regression that invokes the incoming + // filter pipeline more than once per message (which would add extra entries). + Assert.Collection(logMessages, + m => Assert.Equal("MessageFilter1 before", m), + m => Assert.Equal("MessageFilter2 before", m), + m => Assert.Equal("MessageFilter2 after", m), + m => Assert.Equal("MessageFilter1 after", m)); } [Fact] @@ -353,6 +392,11 @@ public async Task AddOutgoingMessageFilter_Sees_Responses_Notifications_And_Requ var clientOptions = new McpClientOptions { + // This test observes the legacy outgoing flow on the server side: the initialize response and + // the server->client sampling/createMessage request. Under the 2026-07-28 protocol those are replaced + // by server/discover and implicit MRTR (InputRequiredResult), which is covered by MrtrIntegrationTests. + // Pin to the latest stable version to keep exercising the legacy server->client request path here. + ProtocolVersion = LatestStableVersion, Capabilities = new() { Sampling = new() }, Handlers = new() { @@ -372,15 +416,20 @@ public async Task AddOutgoingMessageFilter_Sees_Responses_Notifications_And_Requ await client.CallToolAsync("sampling-tool", new Dictionary { ["prompt"] = "Hello" }, cancellationToken: TestContext.Current.CancellationToken); + // Exact counts catch regressions where the outgoing filter pipeline gets applied more than once + // per outbound message (e.g., SendRequestAsync double-wrapping SendToRelatedTransportAsync). + Assert.Equal(1, observedMessages.Count(m => m == "initialize")); + Assert.Equal(2, observedMessages.Count(m => m == "progress")); // ProgressTool sends two NotifyProgressAsync calls + Assert.Equal(2, observedMessages.Count(m => m == "response")); // one tool-call response per CallToolAsync + Assert.Equal(1, observedMessages.Count(m => m == $"request:{RequestMethods.SamplingCreateMessage}")); + + // Preserve the original ordering intent: initialize first, then progress, then the final response. int initializeIndex = observedMessages.IndexOf("initialize"); int progressIndex = observedMessages.IndexOf("progress"); int responseIndex = observedMessages.LastIndexOf("response"); - int requestIndex = observedMessages.IndexOf($"request:{RequestMethods.SamplingCreateMessage}"); - Assert.True(initializeIndex >= 0); Assert.True(progressIndex > initializeIndex); Assert.True(responseIndex > progressIndex); - Assert.True(requestIndex >= 0); } [Fact] @@ -516,7 +565,7 @@ public async Task AddIncomingMessageFilter_SkipNext_DoesNotLogSendingResponse() McpServerBuilder .WithMessageFilters(filters => filters.AddIncomingFilter((next) => (context, cancellationToken) => { - // Skip processing tools/list requests — handler never runs, no response sent + // Skip processing tools/list requests - handler never runs, no response sent if (context.JsonRpcMessage is JsonRpcRequest request && request.Method == RequestMethods.ToolsList) { return Task.CompletedTask; @@ -552,7 +601,7 @@ public async Task AddIncomingMessageFilter_CallsNext_LogsSendingResponse() McpServerBuilder .WithMessageFilters(filters => filters.AddIncomingFilter((next) => (context, cancellationToken) => { - // Pass through — handler runs, response is sent + // Pass through - handler runs, response is sent return next(context, cancellationToken); })) .WithTools(); diff --git a/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsPromptsTests.cs b/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsPromptsTests.cs index 209469e7b..96647fab2 100644 --- a/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsPromptsTests.cs +++ b/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsPromptsTests.cs @@ -1,4 +1,4 @@ -using Microsoft.Extensions.AI; +using Microsoft.Extensions.AI; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Logging; using Microsoft.Extensions.Options; @@ -128,7 +128,14 @@ public async Task Can_List_And_Call_Registered_Prompts() [Fact] public async Task Can_Be_Notified_Of_Prompt_Changes() { - await using McpClient client = await CreateMcpClientForServer(); + // Under the 2026-07-28 protocol, list-changed notifications are delivered only over a + // subscriptions/listen stream (covered by SubscriptionsListenTests). This test pins the + // initialize-handshake revision to keep coverage of the session-wide broadcast that older clients still rely on. + await using McpClient client = await CreateMcpClientForServer(new McpClientOptions + { + ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion, + }); + var prompts = await client.ListPromptsAsync(cancellationToken: TestContext.Current.CancellationToken); Assert.Equal(8, prompts.Count); @@ -166,6 +173,50 @@ public async Task Can_Be_Notified_Of_Prompt_Changes() Assert.DoesNotContain(prompts, t => t.Name == "NewPrompt"); } + [Fact] + public async Task DeferChangedEvents_BatchAddPrompts_EmitsExactlyOneNotification() + { + // Under the 2026-07-28 protocol, list-changed notifications are delivered only over a + // subscriptions/listen stream. Pin the legacy revision to test the session-wide broadcast. + await using McpClient client = await CreateMcpClientForServer(new McpClientOptions + { + ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion, + }); + + var serverOptions = ServiceProvider.GetRequiredService>().Value; + var serverPrompts = serverOptions.PromptCollection; + Assert.NotNull(serverPrompts); + + int notificationCount = 0; + var firstNotification = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + await using (client.RegisterNotificationHandler(NotificationMethods.PromptListChangedNotification, (notification, cancellationToken) => + { + if (Interlocked.Increment(ref notificationCount) == 1) + { + firstNotification.TrySetResult(true); + } + return default; + })) + { + using (serverPrompts.DeferChangedEvents()) + { + serverPrompts.Add(McpServerPrompt.Create([McpServerPrompt(Name = "BatchPrompt1")] () => "1")); + serverPrompts.Add(McpServerPrompt.Create([McpServerPrompt(Name = "BatchPrompt2")] () => "2")); + serverPrompts.Add(McpServerPrompt.Create([McpServerPrompt(Name = "BatchPrompt3")] () => "3")); + } + + await firstNotification.Task.WaitAsync(TestContext.Current.CancellationToken); + + // Do a round-trip so that any second (erroneous) notification has time to arrive. + var prompts = await client.ListPromptsAsync(cancellationToken: TestContext.Current.CancellationToken); + Assert.Contains(prompts, t => t.Name == "BatchPrompt1"); + Assert.Contains(prompts, t => t.Name == "BatchPrompt2"); + Assert.Contains(prompts, t => t.Name == "BatchPrompt3"); + + Assert.Equal(1, notificationCount); + } + } + [Fact] public async Task AttributeProperties_Propagated() { diff --git a/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsRequestFilterTests.cs b/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsRequestFilterTests.cs index 0c4783b28..3f6a4a349 100644 --- a/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsRequestFilterTests.cs +++ b/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsRequestFilterTests.cs @@ -256,7 +256,10 @@ public async Task AddCompleteFilter_Logs_When_Complete_Called() [Fact] public async Task AddSubscribeToResourcesFilter_Logs_When_SubscribeToResources_Called() { - await using McpClient client = await CreateMcpClientForServer(); + await using McpClient client = await CreateMcpClientForServer(new() + { + ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion, + }); await client.SubscribeToResourceAsync("test://resource/123", cancellationToken: TestContext.Current.CancellationToken); @@ -268,7 +271,10 @@ public async Task AddSubscribeToResourcesFilter_Logs_When_SubscribeToResources_C [Fact] public async Task AddUnsubscribeFromResourcesFilter_Logs_When_UnsubscribeFromResources_Called() { - await using McpClient client = await CreateMcpClientForServer(); + await using McpClient client = await CreateMcpClientForServer(new() + { + ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion, + }); await client.UnsubscribeFromResourceAsync("test://resource/123", cancellationToken: TestContext.Current.CancellationToken); @@ -280,7 +286,7 @@ public async Task AddUnsubscribeFromResourcesFilter_Logs_When_UnsubscribeFromRes [Fact] public async Task AddSetLoggingLevelFilter_Logs_When_SetLoggingLevel_Called() { - await using McpClient client = await CreateMcpClientForServer(); + await using McpClient client = await CreateMcpClientForServer(new McpClientOptions { ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion }); await client.SetLoggingLevelAsync(LoggingLevel.Info, cancellationToken: TestContext.Current.CancellationToken); diff --git a/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsResourcesTests.cs b/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsResourcesTests.cs index 4b03cadb2..ff3b9114a 100644 --- a/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsResourcesTests.cs +++ b/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsResourcesTests.cs @@ -1,4 +1,4 @@ -using Microsoft.Extensions.AI; +using Microsoft.Extensions.AI; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Logging; using Microsoft.Extensions.Options; @@ -109,7 +109,7 @@ protected override void ConfigureServices(ServiceCollection services, IMcpServer }; } - throw new McpProtocolException($"Resource not found: {request.Params.Uri}", McpErrorCode.ResourceNotFound); + throw new McpProtocolException($"Resource not found: {request.Params.Uri}", McpErrorCode.InvalidParams); }) .WithResources(); } @@ -162,7 +162,14 @@ public async Task Can_List_And_Call_Registered_ResourceTemplates() [Fact] public async Task Can_Be_Notified_Of_Resource_Changes() { - await using McpClient client = await CreateMcpClientForServer(); + // Under the 2026-07-28 protocol, list-changed notifications are delivered only over a + // subscriptions/listen stream (covered by SubscriptionsListenTests). This test pins the + // initialize-handshake revision to keep coverage of the session-wide broadcast that older clients still rely on. + await using McpClient client = await CreateMcpClientForServer(new McpClientOptions + { + ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion, + }); + var resources = await client.ListResourcesAsync(cancellationToken: TestContext.Current.CancellationToken); Assert.Equal(7, resources.Count); @@ -200,6 +207,50 @@ public async Task Can_Be_Notified_Of_Resource_Changes() Assert.DoesNotContain(resources, t => t.Name == "NewResource"); } + [Fact] + public async Task DeferChangedEvents_BatchAddResources_EmitsExactlyOneNotification() + { + // Under the 2026-07-28 protocol, list-changed notifications are delivered only over a + // subscriptions/listen stream. Pin the legacy revision to test the session-wide broadcast. + await using McpClient client = await CreateMcpClientForServer(new McpClientOptions + { + ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion, + }); + + var serverOptions = ServiceProvider.GetRequiredService>().Value; + var serverResources = serverOptions.ResourceCollection; + Assert.NotNull(serverResources); + + int notificationCount = 0; + var firstNotification = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + await using (client.RegisterNotificationHandler(NotificationMethods.ResourceListChangedNotification, (notification, cancellationToken) => + { + if (Interlocked.Increment(ref notificationCount) == 1) + { + firstNotification.TrySetResult(true); + } + return default; + })) + { + using (serverResources.DeferChangedEvents()) + { + serverResources.Add(McpServerResource.Create([McpServerResource(Name = "BatchResource1", UriTemplate = "test://batch1")] () => "1")); + serverResources.Add(McpServerResource.Create([McpServerResource(Name = "BatchResource2", UriTemplate = "test://batch2")] () => "2")); + serverResources.Add(McpServerResource.Create([McpServerResource(Name = "BatchResource3", UriTemplate = "test://batch3")] () => "3")); + } + + await firstNotification.Task.WaitAsync(TestContext.Current.CancellationToken); + + // Do a round-trip so that any second (erroneous) notification has time to arrive. + var resources = await client.ListResourcesAsync(cancellationToken: TestContext.Current.CancellationToken); + Assert.Contains(resources, t => t.Name == "BatchResource1"); + Assert.Contains(resources, t => t.Name == "BatchResource2"); + Assert.Contains(resources, t => t.Name == "BatchResource3"); + + Assert.Equal(1, notificationCount); + } + } + [Fact] public async Task AttributeProperties_Propagated() { @@ -317,7 +368,7 @@ public async Task Throws_Exception_On_Unknown_Resource() cancellationToken: TestContext.Current.CancellationToken)); Assert.Contains("Resource not found", e.Message); - Assert.Equal(McpErrorCode.ResourceNotFound, e.ErrorCode); + Assert.Equal(McpErrorCode.InvalidParams, e.ErrorCode); } [Fact] diff --git a/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsToolsTests.cs b/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsToolsTests.cs index d2db4c62c..a05084a86 100644 --- a/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsToolsTests.cs +++ b/tests/ModelContextProtocol.Tests/Configuration/McpServerBuilderExtensionsToolsTests.cs @@ -1,4 +1,4 @@ -using Microsoft.Extensions.AI; +using Microsoft.Extensions.AI; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Logging; using Microsoft.Extensions.Options; @@ -188,7 +188,13 @@ public async Task Can_Create_Multiple_Servers_From_Options_And_List_Registered_T [Fact] public async Task Can_Be_Notified_Of_Tool_Changes() { - await using McpClient client = await CreateMcpClientForServer(); + // Under the 2026-07-28 protocol, list-changed notifications are delivered only over a + // subscriptions/listen stream (covered by SubscriptionsListenTests). This test pins the + // initialize-handshake revision to keep coverage of the session-wide broadcast that older clients still rely on. + await using McpClient client = await CreateMcpClientForServer(new McpClientOptions + { + ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion, + }); var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); Assert.Equal(19, tools.Count); @@ -226,6 +232,50 @@ public async Task Can_Be_Notified_Of_Tool_Changes() Assert.DoesNotContain(tools, t => t.Name == "NewTool"); } + [Fact] + public async Task DeferChangedEvents_BatchAddTools_EmitsExactlyOneNotification() + { + // Under the 2026-07-28 protocol, list-changed notifications are delivered only over a + // subscriptions/listen stream. Pin the legacy revision to test the session-wide broadcast. + await using McpClient client = await CreateMcpClientForServer(new McpClientOptions + { + ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion, + }); + + var serverOptions = ServiceProvider.GetRequiredService>().Value; + var serverTools = serverOptions.ToolCollection; + Assert.NotNull(serverTools); + + int notificationCount = 0; + var firstNotification = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + await using (client.RegisterNotificationHandler(NotificationMethods.ToolListChangedNotification, (notification, cancellationToken) => + { + if (Interlocked.Increment(ref notificationCount) == 1) + { + firstNotification.TrySetResult(true); + } + return default; + })) + { + using (serverTools.DeferChangedEvents()) + { + serverTools.Add(McpServerTool.Create([McpServerTool(Name = "BatchTool1")] () => "1")); + serverTools.Add(McpServerTool.Create([McpServerTool(Name = "BatchTool2")] () => "2")); + serverTools.Add(McpServerTool.Create([McpServerTool(Name = "BatchTool3")] () => "3")); + } + + await firstNotification.Task.WaitAsync(TestContext.Current.CancellationToken); + + // Do a round-trip so that any second (erroneous) notification has time to arrive. + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + Assert.Contains(tools, t => t.Name == "BatchTool1"); + Assert.Contains(tools, t => t.Name == "BatchTool2"); + Assert.Contains(tools, t => t.Name == "BatchTool3"); + + Assert.Equal(1, notificationCount); + } + } + [Fact] public async Task Can_Call_Registered_Tool() { diff --git a/tests/ModelContextProtocol.Tests/Configuration/McpServerOptionsSetupTests.cs b/tests/ModelContextProtocol.Tests/Configuration/McpServerOptionsSetupTests.cs index 689aba9d0..dc2eaf805 100644 --- a/tests/ModelContextProtocol.Tests/Configuration/McpServerOptionsSetupTests.cs +++ b/tests/ModelContextProtocol.Tests/Configuration/McpServerOptionsSetupTests.cs @@ -284,57 +284,4 @@ public void Configure_WithCompleteHandler_CreatesCompletionsCapability() Assert.NotNull(options.Capabilities?.Completions); } #endregion - - #region TaskStore Tests - [Fact] - public void TaskStore_IsPopulatedFromDI_WhenNotExplicitlySet() - { - var services = new ServiceCollection(); - services.AddMcpServer(); - services.AddSingleton(); - - var options = services.BuildServiceProvider().GetRequiredService>().Value; - - Assert.IsType(options.TaskStore); - } - - [Fact] - public void TaskStore_ExplicitOption_TakesPrecedenceOverDI() - { - var explicitStore = new InMemoryMcpTaskStore(); - - var services = new ServiceCollection(); - services.AddMcpServer(options => options.TaskStore = explicitStore); - services.AddSingleton(); - - var options = services.BuildServiceProvider().GetRequiredService>().Value; - - Assert.Same(explicitStore, options.TaskStore); - } - - [Fact] - public void TaskStore_RemainsNull_WhenNothingIsRegistered() - { - var services = new ServiceCollection(); - services.AddMcpServer(); - - var options = services.BuildServiceProvider().GetRequiredService>().Value; - - Assert.Null(options.TaskStore); - } - - [Fact] - public void TaskStore_CanBeOverriddenToNull_AfterDIRegistration() - { - var services = new ServiceCollection(); - services.AddMcpServer(); - services.AddSingleton(); - - services.Configure(options => options.TaskStore = null); - - var options = services.BuildServiceProvider().GetRequiredService>().Value; - - Assert.Null(options.TaskStore); - } - #endregion } \ No newline at end of file diff --git a/tests/ModelContextProtocol.Tests/Configuration/McpServerResourceRoutingTests.cs b/tests/ModelContextProtocol.Tests/Configuration/McpServerResourceRoutingTests.cs index 19e0f1bbe..3c070130c 100644 --- a/tests/ModelContextProtocol.Tests/Configuration/McpServerResourceRoutingTests.cs +++ b/tests/ModelContextProtocol.Tests/Configuration/McpServerResourceRoutingTests.cs @@ -1,4 +1,5 @@ using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Options; using ModelContextProtocol.Client; using ModelContextProtocol.Protocol; using ModelContextProtocol.Server; @@ -22,6 +23,23 @@ private async Task CreateClientWithResourcesAsync(params McpServerRes return await CreateMcpClientForServer(); } + /// + /// Starts the server with the specified resources, pins both the server's and the + /// client's protocol version to , and returns a + /// connected client. Both ends must be pinned because strictly + /// compares the server's negotiated version against the client's requested version and + /// refuses to connect on mismatch. + /// + private async Task CreateClientWithResourcesAndServerVersionAsync( + string protocolVersion, + params McpServerResource[] resources) + { + McpServerBuilder.WithResources(resources); + McpServerBuilder.Services.Configure(o => o.ProtocolVersion = protocolVersion); + StartServer(); + return await CreateMcpClientForServer(new McpClientOptions { ProtocolVersion = protocolVersion }); + } + /// /// Asserts that the given URI matches the template and produces the expected text result. /// @@ -40,7 +58,11 @@ private async Task AssertMatchAsync( } /// - /// Asserts that the given URI does NOT match the template. + /// Asserts that the given URI does NOT match the template. Uses the default client, which + /// negotiates the 2026-07-28 protocol revision, so the unknown-resource response carries the + /// standard JSON-RPC (-32602). The version-gated + /// legacy mapping to (-32002) is covered by + /// . /// private async Task AssertNoMatchAsync( string uriTemplate, @@ -53,7 +75,27 @@ private async Task AssertNoMatchAsync( var ex = await Assert.ThrowsAsync(async () => await client.ReadResourceAsync(uri, null, TestContext.Current.CancellationToken)); - Assert.Equal(McpErrorCode.ResourceNotFound, ex.ErrorCode); + Assert.Equal(McpErrorCode.InvalidParams, ex.ErrorCode); + } + + // Unknown-resource-URI responses are version-gated: older clients keep the legacy + // -32002 (McpErrorCode.ResourceNotFound), and clients on the 2026-07-28 protocol version that + // moves to the standard JSON-RPC code see -32602 (McpErrorCode.InvalidParams). + [Theory] + [InlineData("2025-11-25", McpErrorCode.ResourceNotFound)] + [InlineData("2026-07-28", McpErrorCode.InvalidParams)] + public async Task ResourceNotFound_ErrorCode_IsVersionGated(string serverProtocolVersion, McpErrorCode expectedCode) + { + var resource = McpServerResource.Create( + options: new() { UriTemplate = "test://known/{id}" }, + method: (string id) => $"ok: {id}"); + + var client = await CreateClientWithResourcesAndServerVersionAsync(serverProtocolVersion, resource); + + var ex = await Assert.ThrowsAsync(async () => + await client.ReadResourceAsync("test://unknown", null, TestContext.Current.CancellationToken)); + + Assert.Equal(expectedCode, ex.ErrorCode); } /// @@ -92,7 +134,9 @@ public async Task MultipleTemplatedResources_MatchesCorrectResource() // Literal template braces in URI should not match (template literal is not a valid URI) var mcpEx = await Assert.ThrowsAsync(async () => await client.ReadResourceAsync("test://params{?a1,a2,a3}", null, TestContext.Current.CancellationToken)); - Assert.Equal(McpErrorCode.ResourceNotFound, mcpEx.ErrorCode); + // The 2026-07-28 protocol maps an unmatched resource URI to InvalidParams (-32602); the legacy -32002 ResourceNotFound + // mapping is covered by the version-gated ResourceNotFound_ErrorCode_IsVersionGated theory. + Assert.Equal(McpErrorCode.InvalidParams, mcpEx.ErrorCode); Assert.Equal("Request failed (remote): Unknown resource URI: 'test://params{?a1,a2,a3}'", mcpEx.Message); } diff --git a/tests/ModelContextProtocol.Tests/DiagnosticTests.cs b/tests/ModelContextProtocol.Tests/DiagnosticTests.cs index bbe7d153f..db6c2c2c4 100644 --- a/tests/ModelContextProtocol.Tests/DiagnosticTests.cs +++ b/tests/ModelContextProtocol.Tests/DiagnosticTests.cs @@ -18,6 +18,18 @@ public async Task Session_TracksActivities() var activities = new List(); var clientToServerLog = new List(); + // Predicate for the expected server tool-call activity, including all required tags. + // Defined here so it can be reused for both the wait and the assertion below. + Func isExpectedServerToolCall = a => + a.DisplayName == "tools/call DoubleValue" && + a.Kind == ActivityKind.Server && + a.Status == ActivityStatusCode.Unset && + a.Tags.Any(t => t.Key == "gen_ai.tool.name" && t.Value == "DoubleValue") && + a.Tags.Any(t => t.Key == "mcp.method.name" && t.Value == "tools/call") && + a.Tags.Any(t => t.Key == "gen_ai.operation.name" && t.Value == "execute_tool") && + a.Tags.Any(t => t.Key == "mcp.protocol.version" && !string.IsNullOrEmpty(t.Value)) && + a.Tags.Any(t => t.Key == "mcp.session.id" && !string.IsNullOrEmpty(t.Value)); + using (var tracerProvider = OpenTelemetry.Sdk.CreateTracerProviderBuilder() .AddSource("Experimental.ModelContextProtocol") .AddInMemoryExporter(activities) @@ -36,9 +48,11 @@ await RunConnected(async (client, server) => // Wait for server-side activities to be exported. The server processes messages // via fire-and-forget tasks, so activities may not be immediately available // after the client operation completes. Wait for the specific activity we need - // rather than a count, as other server activities may be exported first. - await WaitForAsync(() => activities.Any(a => - a.DisplayName == "tools/call DoubleValue" && a.Kind == ActivityKind.Server)); + // (including required tags) rather than just the display name, so that we don't + // assert before all tags have been populated. + await WaitForAsync( + () => activities.Any(isExpectedServerToolCall), + failureMessage: "Timed out waiting for the expected server tool-call activity (tools/call DoubleValue) to be exported with required tags."); } Assert.NotEmpty(activities); @@ -54,13 +68,7 @@ await WaitForAsync(() => activities.Any(a => // Per semantic conventions: mcp.protocol.version should be present after initialization Assert.Contains(clientToolCall.Tags, t => t.Key == "mcp.protocol.version" && !string.IsNullOrEmpty(t.Value)); - var serverToolCall = Assert.Single(activities, a => - a.Tags.Any(t => t.Key == "gen_ai.tool.name" && t.Value == "DoubleValue") && - a.Tags.Any(t => t.Key == "mcp.method.name" && t.Value == "tools/call") && - a.Tags.Any(t => t.Key == "gen_ai.operation.name" && t.Value == "execute_tool") && - a.DisplayName == "tools/call DoubleValue" && - a.Kind == ActivityKind.Server && - a.Status == ActivityStatusCode.Unset); + var serverToolCall = Assert.Single(activities, a => isExpectedServerToolCall(a)); // Per semantic conventions: mcp.protocol.version should be present after initialization Assert.Contains(serverToolCall.Tags, t => t.Key == "mcp.protocol.version" && !string.IsNullOrEmpty(t.Value)); @@ -83,10 +91,13 @@ await WaitForAsync(() => activities.Any(a => Assert.Equal(clientListToolsCall.SpanId, serverListToolsCall.ParentSpanId); Assert.Equal(clientListToolsCall.TraceId, serverListToolsCall.TraceId); - // Validate that the client trace context encoded to request.params._meta[traceparent] + // Validate that the client trace context encoded to request.params._meta[traceparent]. + // Under the 2026-07-28 protocol _meta also carries the per-request envelope (protocolVersion, + // clientInfo, clientCapabilities), so assert on the traceparent property specifically + // rather than the entire _meta object. using var listToolsJson = JsonDocument.Parse(clientToServerLog.First(s => s.Contains("\"method\":\"tools/list\""))); - var metaJson = listToolsJson.RootElement.GetProperty("params").GetProperty("_meta").GetRawText(); - Assert.Equal($$"""{"traceparent":"00-{{clientListToolsCall.TraceId}}-{{clientListToolsCall.SpanId}}-01"}""", metaJson); + var traceparent = listToolsJson.RootElement.GetProperty("params").GetProperty("_meta").GetProperty("traceparent").GetString(); + Assert.Equal($"00-{clientListToolsCall.TraceId}-{clientListToolsCall.SpanId}-01", traceparent); // Validate that mcp.session.id is set on both client and server activities and that // all client activities share one session ID while all server activities share another. @@ -245,12 +256,19 @@ private static async Task RunConnected(Func action, await serverTask; } - private static async Task WaitForAsync(Func condition, int timeoutMs = 10_000) + private static async Task WaitForAsync(Func condition, int timeoutMs = 10_000, string? failureMessage = null) { using var cts = new CancellationTokenSource(timeoutMs); - while (!condition()) + try + { + while (!condition()) + { + await Task.Delay(10, cts.Token); + } + } + catch (TaskCanceledException) { - await Task.Delay(10, cts.Token); + throw new Xunit.Sdk.XunitException(failureMessage ?? $"Condition was not met within {timeoutMs}ms."); } } } diff --git a/tests/ModelContextProtocol.Tests/ExperimentalPropertySerializationTests.cs b/tests/ModelContextProtocol.Tests/ExperimentalPropertySerializationTests.cs deleted file mode 100644 index d68902ef5..000000000 --- a/tests/ModelContextProtocol.Tests/ExperimentalPropertySerializationTests.cs +++ /dev/null @@ -1,118 +0,0 @@ -using System.Text.Json; -using System.Text.Json.Serialization; -using ModelContextProtocol.Protocol; - -namespace ModelContextProtocol.Tests; - -/// -/// Validates that the internal property pattern used for experimental properties -/// produces the expected serialization behavior for SDK consumers using source generators. -/// -/// -/// -/// Experimental properties (e.g. , ) -/// use an internal *Core property for serialization. A consumer's source-generated -/// cannot see internal members, so experimental data is -/// silently dropped unless the consumer chains the SDK's resolver into their options. -/// -/// -/// These tests depend on and -/// being experimental. When those APIs stabilize, update these tests to reference whatever -/// experimental properties exist at that time, or remove them entirely if no experimental -/// APIs remain. -/// -/// -public class ExperimentalPropertySerializationTests -{ - [Fact] - public void ExperimentalProperties_Dropped_WithConsumerContextOnly() - { - var options = new JsonSerializerOptions - { - TypeInfoResolverChain = { ConsumerJsonContext.Default } - }; - - var tool = new Tool - { - Name = "test-tool", - Execution = new ToolExecution { TaskSupport = ToolTaskSupport.Optional } - }; - - string json = JsonSerializer.Serialize(tool, options); - Assert.DoesNotContain("\"execution\"", json); - Assert.Contains("\"name\"", json); - } - - [Fact] - public void ExperimentalProperties_IgnoredOnDeserialize_WithConsumerContextOnly() - { - string json = JsonSerializer.Serialize( - new Tool - { - Name = "test-tool", - Execution = new ToolExecution { TaskSupport = ToolTaskSupport.Optional } - }, - McpJsonUtilities.DefaultOptions); - Assert.Contains("\"execution\"", json); - - var options = new JsonSerializerOptions - { - TypeInfoResolverChain = { ConsumerJsonContext.Default } - }; - var deserialized = JsonSerializer.Deserialize(json, options)!; - Assert.Equal("test-tool", deserialized.Name); - Assert.Null(deserialized.Execution); - } - - [Fact] - public void ExperimentalProperties_RoundTrip_WhenSdkResolverIsChained() - { - var options = new JsonSerializerOptions - { - TypeInfoResolverChain = - { - McpJsonUtilities.DefaultOptions.TypeInfoResolver!, - ConsumerJsonContext.Default, - } - }; - - var tool = new Tool - { - Name = "test-tool", - Execution = new ToolExecution { TaskSupport = ToolTaskSupport.Optional } - }; - - string json = JsonSerializer.Serialize(tool, options); - Assert.Contains("\"execution\"", json); - Assert.Contains("\"name\"", json); - - var deserialized = JsonSerializer.Deserialize(json, options)!; - Assert.Equal("test-tool", deserialized.Name); - Assert.NotNull(deserialized.Execution); - Assert.Equal(ToolTaskSupport.Optional, deserialized.Execution.TaskSupport); - } - - [Fact] - public void ExperimentalProperties_RoundTrip_WithDefaultOptions() - { - var capabilities = new ServerCapabilities - { - Tasks = new McpTasksCapability() - }; - - string json = JsonSerializer.Serialize(capabilities, McpJsonUtilities.DefaultOptions); - Assert.Contains("\"tasks\"", json); - - var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions)!; - Assert.NotNull(deserialized.Tasks); - } -} - -[JsonSerializable(typeof(Tool))] -[JsonSerializable(typeof(ServerCapabilities))] -[JsonSerializable(typeof(ClientCapabilities))] -[JsonSerializable(typeof(CallToolResult))] -[JsonSerializable(typeof(CallToolRequestParams))] -[JsonSerializable(typeof(CreateMessageRequestParams))] -[JsonSerializable(typeof(ElicitRequestParams))] -internal partial class ConsumerJsonContext : JsonSerializerContext; diff --git a/tests/ModelContextProtocol.Tests/IdentityAssertionGrantTests.cs b/tests/ModelContextProtocol.Tests/IdentityAssertionGrantTests.cs new file mode 100644 index 000000000..92e81c93c --- /dev/null +++ b/tests/ModelContextProtocol.Tests/IdentityAssertionGrantTests.cs @@ -0,0 +1,596 @@ +using System.Net; +using System.Text.Json.Nodes; +using ModelContextProtocol.Authentication; + +namespace ModelContextProtocol.Tests; + +public sealed class IdentityAssertionGrantTests : IDisposable +{ + private readonly MockHttpMessageHandler _mockHandler; + private readonly HttpClient _httpClient; + + public IdentityAssertionGrantTests() + { + _mockHandler = new MockHttpMessageHandler(); + _httpClient = new HttpClient(_mockHandler); + } + + public void Dispose() + { + _httpClient.Dispose(); + _mockHandler.Dispose(); + } + + #region IdentityAssertionGrantProvider Tests + + [Fact] + public async Task IdentityAssertionGrantProvider_FullFlow_ReturnsAccessToken() + { + _mockHandler.Handler = request => + { + var url = request.RequestUri!.ToString(); + + if (url.Contains(".well-known/openid-configuration")) + { + return JsonResponse(HttpStatusCode.OK, new JsonObject + { + ["issuer"] = "https://auth.mcp-server.example.com", + ["authorization_endpoint"] = "https://auth.mcp-server.example.com/authorize", + ["token_endpoint"] = "https://auth.mcp-server.example.com/token", + ["token_endpoint_auth_methods_supported"] = new JsonArray("client_secret_basic"), + }); + } + + if (url.Contains("idp.example.com/token")) + { + return JsonResponse(HttpStatusCode.OK, new JsonObject + { + ["access_token"] = "mock-jag-assertion", + ["issued_token_type"] = "urn:ietf:params:oauth:token-type:id-jag", + ["token_type"] = "N_A", + }); + } + + if (url.Contains("auth.mcp-server.example.com/token")) + { + Assert.Equal("Basic", request.Headers.Authorization?.Scheme); + Assert.Equal( + Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes("mcp-client-id:mcp-client-secret")), + request.Headers.Authorization?.Parameter); + return JsonResponse(HttpStatusCode.OK, new JsonObject + { + ["access_token"] = "final-access-token", + ["token_type"] = "Bearer", + ["expires_in"] = 3600, + }); + } + + return new HttpResponseMessage(HttpStatusCode.NotFound); + }; + + var provider = new IdentityAssertionGrantProvider( + new IdentityAssertionGrantProviderOptions + { + ClientId = "mcp-client-id", + ClientSecret = "mcp-client-secret", + TokenEndpointAuthMethod = "client_secret_basic", + IdpTokenEndpoint = "https://idp.example.com/token", + IdpClientId = "idp-client-id", + IdTokenCallback = (context, ct) => + { + Assert.Equal(new Uri("https://mcp-server.example.com"), context.ResourceUrl); + Assert.Equal(new Uri("https://auth.mcp-server.example.com"), context.AuthorizationServerUrl); + return Task.FromResult("mock-id-token"); + }, + }, + _httpClient); + + var tokens = await provider.GetAccessTokenAsync( + resourceUrl: new Uri("https://mcp-server.example.com"), + authorizationServerUrl: new Uri("https://auth.mcp-server.example.com"), + TestContext.Current.CancellationToken); + + Assert.Equal("final-access-token", tokens.AccessToken); + Assert.Equal("Bearer", tokens.TokenType); + Assert.Equal(3600, tokens.ExpiresIn); + } + + [Fact] + public Task IdentityAssertionGrantProvider_DefaultsToPostRegardlessOfMetadataOrder() => + AssertMcpTokenEndpointAuthenticationAsync( + new JsonArray("client_secret_basic", "client_secret_post"), + configuredMethod: null, + expectedAuthorizationScheme: null, + expectSecretInBody: true); + + [Fact] + public Task IdentityAssertionGrantProvider_FallsBackToBasicWhenPostIsUnavailable() => + AssertMcpTokenEndpointAuthenticationAsync( + new JsonArray("client_secret_basic"), + configuredMethod: null, + expectedAuthorizationScheme: "Basic", + expectSecretInBody: false); + + [Fact] + public Task IdentityAssertionGrantProvider_NoneDoesNotSendClientSecret() => + AssertMcpTokenEndpointAuthenticationAsync( + new JsonArray("none"), + configuredMethod: "none", + expectedAuthorizationScheme: null, + expectSecretInBody: false); + + [Fact] + public async Task IdentityAssertionGrantProvider_CachesTokens() + { + var mcpTokenCallCount = 0; + _mockHandler.Handler = request => + { + var url = request.RequestUri!.ToString(); + if (url.Contains(".well-known")) + { + return JsonResponse(HttpStatusCode.OK, new JsonObject + { + ["authorization_endpoint"] = "https://auth.example.com/authorize", + ["token_endpoint"] = "https://auth.example.com/token", + }); + } + + if (url.Contains("idp.example.com")) + { + return JsonResponse(HttpStatusCode.OK, new JsonObject + { + ["access_token"] = "mock-jag", + ["issued_token_type"] = "urn:ietf:params:oauth:token-type:id-jag", + ["token_type"] = "N_A", + }); + } + + mcpTokenCallCount++; + return JsonResponse(HttpStatusCode.OK, new JsonObject + { + ["access_token"] = "cached-token", + ["token_type"] = "Bearer", + ["expires_in"] = 3600, + }); + }; + + var idTokenCallCount = 0; + var provider = new IdentityAssertionGrantProvider( + new IdentityAssertionGrantProviderOptions + { + ClientId = "client-id", + IdpTokenEndpoint = "https://idp.example.com/token", + IdpClientId = "idp-client-id", + IdTokenCallback = (_, _) => + { + idTokenCallCount++; + return Task.FromResult("mock-id-token"); + }, + }, + _httpClient); + + var ct = TestContext.Current.CancellationToken; + + var firstTokens = await provider.GetAccessTokenAsync( + new Uri("https://resource.example.com"), + new Uri("https://auth.example.com"), ct); + + var secondTokens = await provider.GetAccessTokenAsync( + new Uri("https://resource.example.com"), + new Uri("https://auth.example.com"), ct); + + Assert.Same(firstTokens, secondTokens); + Assert.Equal(1, idTokenCallCount); + Assert.Equal(1, mcpTokenCallCount); + } + + [Fact] + public async Task IdentityAssertionGrantProvider_InvalidateCache_ForcesRefresh() + { + var idTokenCallCount = 0; + _mockHandler.Handler = request => + { + var url = request.RequestUri!.ToString(); + if (url.Contains(".well-known")) + { + return JsonResponse(HttpStatusCode.OK, new JsonObject + { + ["authorization_endpoint"] = "https://auth.example.com/authorize", + ["token_endpoint"] = "https://auth.example.com/token", + }); + } + + if (url.Contains("idp.example.com")) + { + return JsonResponse(HttpStatusCode.OK, new JsonObject + { + ["access_token"] = "mock-jag", + ["issued_token_type"] = "urn:ietf:params:oauth:token-type:id-jag", + ["token_type"] = "N_A", + }); + } + + return JsonResponse(HttpStatusCode.OK, new JsonObject + { + ["access_token"] = $"token-{idTokenCallCount}", + ["token_type"] = "Bearer", + ["expires_in"] = 3600, + }); + }; + + var provider = new IdentityAssertionGrantProvider( + new IdentityAssertionGrantProviderOptions + { + ClientId = "client-id", + IdpTokenEndpoint = "https://idp.example.com/token", + IdpClientId = "idp-client-id", + IdTokenCallback = (_, _) => + { + idTokenCallCount++; + return Task.FromResult("mock-id-token"); + }, + }, + _httpClient); + + var ct = TestContext.Current.CancellationToken; + + await provider.GetAccessTokenAsync( + new Uri("https://resource.example.com"), + new Uri("https://auth.example.com"), ct); + + provider.InvalidateCache(); + + await provider.GetAccessTokenAsync( + new Uri("https://resource.example.com"), + new Uri("https://auth.example.com"), ct); + + Assert.Equal(2, idTokenCallCount); + } + + [Fact] + public async Task IdentityAssertionGrantProvider_IdTokenCallbackReturnsEmpty_ThrowsException() + { + _mockHandler.Handler = request => + { + var url = request.RequestUri!.ToString(); + if (url.Contains(".well-known")) + { + return JsonResponse(HttpStatusCode.OK, new JsonObject + { + ["authorization_endpoint"] = "https://auth.example.com/authorize", + ["token_endpoint"] = "https://auth.example.com/token", + }); + } + + return new HttpResponseMessage(HttpStatusCode.NotFound); + }; + + var provider = new IdentityAssertionGrantProvider( + new IdentityAssertionGrantProviderOptions + { + ClientId = "client-id", + IdpTokenEndpoint = "https://idp.example.com/token", + IdpClientId = "idp-client-id", + IdTokenCallback = (_, _) => Task.FromResult(string.Empty), + }, + _httpClient); + + await Assert.ThrowsAsync( + () => provider.GetAccessTokenAsync( + new Uri("https://resource.example.com"), + new Uri("https://auth.example.com"), + TestContext.Current.CancellationToken)); + } + + [Fact] + public void IdentityAssertionGrantProvider_NullOptions_ThrowsArgumentNullException() + { + Assert.Throws(() => new IdentityAssertionGrantProvider(null!, _httpClient)); + } + + [Fact] + public void IdentityAssertionGrantProvider_NullHttpClient_ThrowsArgumentNullException() + { + Assert.Throws(() => new IdentityAssertionGrantProvider( + new IdentityAssertionGrantProviderOptions + { + ClientId = "client-id", + IdpTokenEndpoint = "https://idp.example.com/token", + IdpClientId = "idp-client-id", + IdTokenCallback = (_, _) => Task.FromResult("token"), + }, + null!)); + } + + [Fact] + public void IdentityAssertionGrantProvider_MissingClientId_ThrowsArgumentException() + { + Assert.Throws(() => new IdentityAssertionGrantProvider( + new IdentityAssertionGrantProviderOptions + { + ClientId = "", + IdpTokenEndpoint = "https://idp.example.com/token", + IdpClientId = "idp-client-id", + IdTokenCallback = (_, _) => Task.FromResult("test"), + }, + _httpClient)); + } + + [Fact] + public void IdentityAssertionGrantProvider_MissingIdTokenCallback_ThrowsArgumentNullException() + { + Assert.Throws(() => new IdentityAssertionGrantProvider( + new IdentityAssertionGrantProviderOptions + { + ClientId = "client-id", + IdpTokenEndpoint = "https://idp.example.com/token", + IdpClientId = "idp-client-id", + IdTokenCallback = null!, + }, + _httpClient)); + } + + [Fact] + public void IdentityAssertionGrantProvider_MissingIdpConfig_ThrowsArgumentException() + { + Assert.Throws(() => new IdentityAssertionGrantProvider( + new IdentityAssertionGrantProviderOptions + { + ClientId = "client-id", + IdpClientId = "idp-client-id", + // Neither IdpUrl nor IdpTokenEndpoint provided + IdTokenCallback = (_, _) => Task.FromResult("test"), + }, + _httpClient)); + } + + [Theory] + [InlineData("client_secret_basic")] + [InlineData("client_secret_post")] + public void IdentityAssertionGrantProvider_TokenEndpointAuthMethodRequiresSecret_MissingClientSecret_ThrowsArgumentException(string tokenEndpointAuthMethod) + { + Assert.Throws(() => new IdentityAssertionGrantProvider( + new IdentityAssertionGrantProviderOptions + { + ClientId = "client-id", + IdpTokenEndpoint = "https://idp.example.com/token", + IdpClientId = "idp-client-id", + IdTokenCallback = (_, _) => Task.FromResult("test"), + TokenEndpointAuthMethod = tokenEndpointAuthMethod, + ClientSecret = null, + }, + _httpClient)); + } + + [Fact] + public void IdentityAssertionGrantProvider_UnsupportedTokenEndpointAuthMethod_ThrowsArgumentException() + { + Assert.Throws(() => new IdentityAssertionGrantProvider( + new IdentityAssertionGrantProviderOptions + { + ClientId = "client-id", + IdpTokenEndpoint = "https://idp.example.com/token", + IdpClientId = "idp-client-id", + IdTokenCallback = (_, _) => Task.FromResult("test"), + TokenEndpointAuthMethod = "private_key_jwt", + }, + _httpClient)); + } + + [Fact] + public async Task IdentityAssertionGrantProvider_ConcurrentCallers_RunExchangeOnce() + { + // Gate the first in-flight flow so multiple callers overlap while the first holds the + // acquisition lock. Without coalescing, each concurrent caller would run its own exchange. + var firstEntered = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + var release = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + + var mcpTokenCallCount = 0; + _mockHandler.AsyncHandler = async request => + { + var url = request.RequestUri!.ToString(); + if (url.Contains(".well-known")) + { + return JsonResponse(HttpStatusCode.OK, new JsonObject + { + ["authorization_endpoint"] = "https://auth.example.com/authorize", + ["token_endpoint"] = "https://auth.example.com/token", + }); + } + + if (url.Contains("idp.example.com")) + { + return JsonResponse(HttpStatusCode.OK, new JsonObject + { + ["access_token"] = "mock-jag", + ["issued_token_type"] = "urn:ietf:params:oauth:token-type:id-jag", + ["token_type"] = "N_A", + }); + } + + // MCP token endpoint: this is the exchange we expect to run exactly once. + if (Interlocked.Increment(ref mcpTokenCallCount) == 1) + { + firstEntered.TrySetResult(true); + await release.Task; + } + + return JsonResponse(HttpStatusCode.OK, new JsonObject + { + ["access_token"] = "final-access-token", + ["token_type"] = "Bearer", + ["expires_in"] = 3600, + }); + }; + + var idTokenCallCount = 0; + var provider = new IdentityAssertionGrantProvider( + new IdentityAssertionGrantProviderOptions + { + ClientId = "mcp-client-id", + IdpTokenEndpoint = "https://idp.example.com/token", + IdpClientId = "idp-client-id", + IdTokenCallback = (_, _) => + { + Interlocked.Increment(ref idTokenCallCount); + return Task.FromResult("mock-id-token"); + }, + }, + _httpClient); + + var ct = TestContext.Current.CancellationToken; + var resourceUrl = new Uri("https://resource.example.com"); + var authUrl = new Uri("https://auth.example.com"); + + var tasks = Enumerable.Range(0, 8) + .Select(_ => provider.GetAccessTokenAsync(resourceUrl, authUrl, ct)) + .ToArray(); + + // Wait until the first flow is inside the exchange (holding the lock), then let it finish. + var entered = await Task.WhenAny(firstEntered.Task, Task.Delay(TimeSpan.FromSeconds(30), ct)); + Assert.Same(firstEntered.Task, entered); + release.SetResult(true); + + var results = await Task.WhenAll(tasks); + + Assert.Equal(1, mcpTokenCallCount); + Assert.Equal(1, idTokenCallCount); + Assert.All(results, r => Assert.Same(results[0], r)); + Assert.Equal("final-access-token", results[0].AccessToken); + } + + #endregion + + #region IdentityAssertionGrantException Tests + + [Fact] + public void IdentityAssertionGrantException_WithErrorCodeAndDescription_FormatsMessage() + { + var ex = new IdentityAssertionGrantException("Base message", "invalid_grant", "Token expired"); + + Assert.Contains("Base message", ex.Message); + Assert.Contains("invalid_grant", ex.Message); + Assert.Contains("Token expired", ex.Message); + Assert.Equal("invalid_grant", ex.ErrorCode); + Assert.Equal("Token expired", ex.ErrorDescription); + } + + [Fact] + public void IdentityAssertionGrantException_WithErrorUri_StoresIt() + { + var ex = new IdentityAssertionGrantException("msg", "error", "desc", "https://docs.example.com/error"); + + Assert.Equal("https://docs.example.com/error", ex.ErrorUri); + } + + [Fact] + public void IdentityAssertionGrantException_WithoutErrorDetails_PlainMessage() + { + var ex = new IdentityAssertionGrantException("Simple error"); + + Assert.Equal("Simple error", ex.Message); + Assert.Null(ex.ErrorCode); + Assert.Null(ex.ErrorDescription); + Assert.Null(ex.ErrorUri); + } + + #endregion + + #region Helpers + + private async Task AssertMcpTokenEndpointAuthenticationAsync( + JsonArray supportedMethods, + string? configuredMethod, + string? expectedAuthorizationScheme, + bool expectSecretInBody) + { + _mockHandler.AsyncHandler = async request => + { + var url = request.RequestUri!.ToString(); + if (url.Contains(".well-known")) + { + return JsonResponse(HttpStatusCode.OK, new JsonObject + { + ["issuer"] = "https://auth.example.com", + ["authorization_endpoint"] = "https://auth.example.com/authorize", + ["token_endpoint"] = "https://auth.example.com/token", + ["token_endpoint_auth_methods_supported"] = supportedMethods, + }); + } + + if (url.Contains("idp.example.com")) + { + return JsonResponse(HttpStatusCode.OK, new JsonObject + { + ["access_token"] = "mock-jag", + ["issued_token_type"] = "urn:ietf:params:oauth:token-type:id-jag", + ["token_type"] = "N_A", + }); + } + + Assert.Equal(expectedAuthorizationScheme, request.Headers.Authorization?.Scheme); + var body = await request.Content!.ReadAsStringAsync(TestContext.Current.CancellationToken); + Assert.Equal(expectSecretInBody, body.Contains("client_secret=mcp-client-secret", StringComparison.Ordinal)); + + return JsonResponse(HttpStatusCode.OK, new JsonObject + { + ["access_token"] = "final-access-token", + ["token_type"] = "Bearer", + }); + }; + + var provider = new IdentityAssertionGrantProvider( + new IdentityAssertionGrantProviderOptions + { + ClientId = "mcp-client-id", + ClientSecret = "mcp-client-secret", + TokenEndpointAuthMethod = configuredMethod, + IdpTokenEndpoint = "https://idp.example.com/token", + IdpClientId = "idp-client-id", + IdTokenCallback = (_, _) => Task.FromResult("mock-id-token"), + }, + _httpClient); + + var tokens = await provider.GetAccessTokenAsync( + new Uri("https://resource.example.com"), + new Uri("https://auth.example.com"), + TestContext.Current.CancellationToken); + + Assert.Equal("final-access-token", tokens.AccessToken); + } + + private static HttpResponseMessage JsonResponse(HttpStatusCode statusCode, JsonObject payload) + { + return new HttpResponseMessage(statusCode) + { + Content = new StringContent(payload.ToJsonString(), System.Text.Encoding.UTF8, "application/json") + }; + } + + private sealed class MockHttpMessageHandler : HttpMessageHandler + { + public Func? Handler { get; set; } + public Func>? AsyncHandler { get; set; } + + protected override async Task SendAsync( + HttpRequestMessage request, CancellationToken cancellationToken) + { + if (AsyncHandler is not null) + { + return await AsyncHandler(request); + } + + if (Handler is not null) + { + return Handler(request); + } + + return new HttpResponseMessage(HttpStatusCode.InternalServerError) + { + Content = new StringContent("No mock response configured") + }; + } + } + + #endregion +} diff --git a/tests/ModelContextProtocol.Tests/McpProtocolExceptionDataTests.cs b/tests/ModelContextProtocol.Tests/McpProtocolExceptionDataTests.cs index 7d50a3044..336f58382 100644 --- a/tests/ModelContextProtocol.Tests/McpProtocolExceptionDataTests.cs +++ b/tests/ModelContextProtocol.Tests/McpProtocolExceptionDataTests.cs @@ -33,7 +33,7 @@ protected override void ConfigureServices(ServiceCollection services, IMcpServer switch (toolName) { case "throw_with_serializable_data": - throw new McpProtocolException("Resource not found", McpErrorCode.ResourceNotFound) + throw new McpProtocolException("Resource not found", McpErrorCode.InvalidParams) { Data = { @@ -43,7 +43,7 @@ protected override void ConfigureServices(ServiceCollection services, IMcpServer }; case "throw_with_nonserializable_data": - throw new McpProtocolException("Resource not found", McpErrorCode.ResourceNotFound) + throw new McpProtocolException("Resource not found", McpErrorCode.InvalidParams) { Data = { @@ -55,7 +55,7 @@ protected override void ConfigureServices(ServiceCollection services, IMcpServer }; case "throw_with_only_nonserializable_data": - throw new McpProtocolException("Resource not found", McpErrorCode.ResourceNotFound) + throw new McpProtocolException("Resource not found", McpErrorCode.InvalidParams) { Data = { @@ -79,7 +79,7 @@ public async Task Exception_With_Serializable_Data_Propagates_To_Client() await client.CallToolAsync("throw_with_serializable_data", cancellationToken: TestContext.Current.CancellationToken)); Assert.Equal("Request failed (remote): Resource not found", exception.Message); - Assert.Equal(McpErrorCode.ResourceNotFound, exception.ErrorCode); + Assert.Equal(McpErrorCode.InvalidParams, exception.ErrorCode); // Verify the data was propagated to the exception // The Data collection should contain the expected keys @@ -113,7 +113,7 @@ public async Task Exception_With_NonSerializable_Data_Still_Propagates_Error_To_ await client.CallToolAsync("throw_with_nonserializable_data", cancellationToken: TestContext.Current.CancellationToken)); Assert.Equal("Request failed (remote): Resource not found", exception.Message); - Assert.Equal(McpErrorCode.ResourceNotFound, exception.ErrorCode); + Assert.Equal(McpErrorCode.InvalidParams, exception.ErrorCode); // Verify that only the serializable data was propagated (non-serializable was filtered out) var hasUri = false; @@ -142,7 +142,7 @@ public async Task Exception_With_Only_NonSerializable_Data_Still_Propagates_Erro await client.CallToolAsync("throw_with_only_nonserializable_data", cancellationToken: TestContext.Current.CancellationToken)); Assert.Equal("Request failed (remote): Resource not found", exception.Message); - Assert.Equal(McpErrorCode.ResourceNotFound, exception.ErrorCode); + Assert.Equal(McpErrorCode.InvalidParams, exception.ErrorCode); // When all data is non-serializable, the Data collection should be empty // (the server's ConvertExceptionData returns null when no serializable data exists) diff --git a/tests/ModelContextProtocol.Tests/ModelContextProtocol.Tests.csproj b/tests/ModelContextProtocol.Tests/ModelContextProtocol.Tests.csproj index 0985f4cd7..677d77357 100644 --- a/tests/ModelContextProtocol.Tests/ModelContextProtocol.Tests.csproj +++ b/tests/ModelContextProtocol.Tests/ModelContextProtocol.Tests.csproj @@ -1,4 +1,4 @@ - + Exe @@ -11,7 +11,7 @@ true ModelContextProtocol.Tests - $(NoWarn);NU1903;NU1902 + $(NoWarn);NU1903;NU1902;MCP9006 $(DefineConstants);MCP_TEST_TIME_PROVIDER @@ -35,10 +35,8 @@ - - - - + + @@ -85,6 +83,8 @@ + + diff --git a/tests/ModelContextProtocol.Tests/Protocol/CacheableResultClientServerTests.cs b/tests/ModelContextProtocol.Tests/Protocol/CacheableResultClientServerTests.cs new file mode 100644 index 000000000..f460172d5 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Protocol/CacheableResultClientServerTests.cs @@ -0,0 +1,93 @@ +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; + +namespace ModelContextProtocol.Tests.Protocol; + +/// +/// End-to-end tests verifying that SEP-2549 caching hints set by a server on cacheable results +/// are observed by a connected client. +/// +public class CacheableResultClientServerTests(ITestOutputHelper testOutputHelper) + : ClientServerTestBase(testOutputHelper) +{ + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + mcpServerBuilder + .WithListToolsHandler((_, _) => new ValueTask(new ListToolsResult + { + Tools = [new Tool { Name = "echo" }], + TimeToLive = TimeSpan.FromMinutes(5), + CacheScope = CacheScope.Public, + })) + .WithListPromptsHandler((_, _) => new ValueTask(new ListPromptsResult + { + Prompts = [new Prompt { Name = "greet" }], + })) + .WithListResourcesHandler((_, _) => new ValueTask(new ListResourcesResult + { + Resources = [new Resource { Uri = "test://resource", Name = "resource" }], + })) + .WithReadResourceHandler((request, _) => new ValueTask(new ReadResourceResult + { + Contents = [new TextResourceContents { Uri = request.Params!.Uri!, Text = "hi" }], + TimeToLive = TimeSpan.FromSeconds(30), + CacheScope = CacheScope.Private, + })); + } + + [Fact] + public async Task ListTools_PropagatesCachingHints_ToClient() + { + await using var client = await CreateMcpClientForServer(); + + var result = await client.ListToolsAsync( + new ListToolsRequestParams(), + TestContext.Current.CancellationToken); + + Assert.Equal(TimeSpan.FromMinutes(5), result.TimeToLive); + Assert.Equal(CacheScope.Public, result.CacheScope); + } + + [Fact] + public async Task ReadResource_PropagatesCachingHints_ToClient() + { + await using var client = await CreateMcpClientForServer(); + + var result = await client.ReadResourceAsync( + "test://resource", + cancellationToken: TestContext.Current.CancellationToken); + + Assert.Equal(TimeSpan.FromSeconds(30), result.TimeToLive); + Assert.Equal(CacheScope.Private, result.CacheScope); + } + + [Fact] + public async Task ListPrompts_WhenHandlerOmitsHints_ServerInjectsConservativeDefaults() + { + await using var client = await CreateMcpClientForServer(); + + var result = await client.ListPromptsAsync( + new ListPromptsRequestParams(), + TestContext.Current.CancellationToken); + + // SEP-2549: the handler left the hints unset, so the server fills in conservative defaults + // (immediately stale, not shareable) rather than omitting the now-required fields. + Assert.Equal(TimeSpan.Zero, result.TimeToLive); + Assert.Equal(CacheScope.Private, result.CacheScope); + } + + [Fact] + public async Task ListResources_WhenHandlerOmitsHints_ServerInjectsConservativeDefaults() + { + await using var client = await CreateMcpClientForServer(); + + var result = await client.ListResourcesAsync( + new ListResourcesRequestParams(), + TestContext.Current.CancellationToken); + + Assert.Equal(TimeSpan.Zero, result.TimeToLive); + Assert.Equal(CacheScope.Private, result.CacheScope); + } +} diff --git a/tests/ModelContextProtocol.Tests/Protocol/CacheableResultTests.cs b/tests/ModelContextProtocol.Tests/Protocol/CacheableResultTests.cs new file mode 100644 index 000000000..aba38bfa0 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Protocol/CacheableResultTests.cs @@ -0,0 +1,292 @@ +using ModelContextProtocol.Protocol; +using System.Text.Json; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.Tests.Protocol; + +/// +/// Tests for the SEP-2549 caching hints (ttlMs and cacheScope) carried by +/// implementations: the results of tools/list, +/// prompts/list, resources/list, resources/templates/list, and +/// resources/read. +/// +public static class CacheableResultTests +{ + public static IEnumerable CacheableResultTypes() + { + yield return new object[] { typeof(ListToolsResult) }; + yield return new object[] { typeof(ListPromptsResult) }; + yield return new object[] { typeof(ListResourcesResult) }; + yield return new object[] { typeof(ListResourceTemplatesResult) }; + yield return new object[] { typeof(ReadResourceResult) }; + } + + [Theory] + [MemberData(nameof(CacheableResultTypes))] + public static void CacheableResult_SerializesTtlMsAsIntegerMilliseconds(Type type) + { + var result = (ICacheableResult)Activator.CreateInstance(type)!; + result.TimeToLive = TimeSpan.FromMilliseconds(300_000); + result.CacheScope = CacheScope.Public; + + string json = JsonSerializer.Serialize(result, type, McpJsonUtilities.DefaultOptions); + var node = JsonNode.Parse(json)!.AsObject(); + + Assert.True(node.ContainsKey("ttlMs")); + Assert.Equal(JsonValueKind.Number, node["ttlMs"]!.GetValueKind()); + Assert.Equal(300_000, node["ttlMs"]!.GetValue()); + Assert.Equal("public", node["cacheScope"]!.GetValue()); + + var deserialized = (ICacheableResult)JsonSerializer.Deserialize(json, type, McpJsonUtilities.DefaultOptions)!; + Assert.Equal(TimeSpan.FromMilliseconds(300_000), deserialized.TimeToLive); + Assert.Equal(CacheScope.Public, deserialized.CacheScope); + } + + [Theory] + [MemberData(nameof(CacheableResultTypes))] + public static void CacheableResult_PrivateScope_RoundTrips(Type type) + { + var result = (ICacheableResult)Activator.CreateInstance(type)!; + result.TimeToLive = TimeSpan.Zero; + result.CacheScope = CacheScope.Private; + + string json = JsonSerializer.Serialize(result, type, McpJsonUtilities.DefaultOptions); + var node = JsonNode.Parse(json)!.AsObject(); + + // A TTL of zero is meaningful (immediately stale) and must still be emitted. + Assert.True(node.ContainsKey("ttlMs")); + Assert.Equal(0, node["ttlMs"]!.GetValue()); + Assert.Equal("private", node["cacheScope"]!.GetValue()); + + var deserialized = (ICacheableResult)JsonSerializer.Deserialize(json, type, McpJsonUtilities.DefaultOptions)!; + Assert.Equal(TimeSpan.Zero, deserialized.TimeToLive); + Assert.Equal(CacheScope.Private, deserialized.CacheScope); + } + + [Theory] + [MemberData(nameof(CacheableResultTypes))] + public static void CacheableResult_OmitsCachingHints_WhenUnset(Type type) + { + object result = Activator.CreateInstance(type)!; + + string json = JsonSerializer.Serialize(result, type, McpJsonUtilities.DefaultOptions); + var node = JsonNode.Parse(json)!.AsObject(); + + // Backward compatibility: servers that do not set the hints must not emit them. + Assert.False(node.ContainsKey("ttlMs")); + Assert.False(node.ContainsKey("cacheScope")); + + var deserialized = (ICacheableResult)JsonSerializer.Deserialize(json, type, McpJsonUtilities.DefaultOptions)!; + Assert.Null(deserialized.TimeToLive); + Assert.Null(deserialized.CacheScope); + } + + [Theory] + [MemberData(nameof(CacheableResultTypes))] + public static void CacheableResult_DeserializesMissingHints_AsNull(Type type) + { + // A response from a server that predates SEP-2549 contains neither field. + string json = "{}"; + + var deserialized = (ICacheableResult)JsonSerializer.Deserialize(json, type, McpJsonUtilities.DefaultOptions)!; + Assert.Null(deserialized.TimeToLive); + Assert.Null(deserialized.CacheScope); + } + + [Theory] + [MemberData(nameof(CacheableResultTypes))] + public static void CacheableResult_DeserializesNegativeTtl(Type type) + { + // Per SEP-2549, a negative ttlMs is preserved on the DTO; callers SHOULD treat it as zero. + string json = "{\"ttlMs\":-5,\"cacheScope\":\"public\"}"; + + var deserialized = (ICacheableResult)JsonSerializer.Deserialize(json, type, McpJsonUtilities.DefaultOptions)!; + Assert.Equal(TimeSpan.FromMilliseconds(-5), deserialized.TimeToLive); + } + + [Theory] + [MemberData(nameof(CacheableResultTypes))] + public static void CacheableResult_DeserializesOversizedTtl_ClampsInsteadOfThrowing(Type type) + { + // A hostile or buggy server could return a ttlMs that is a valid JSON integer but exceeds the + // range representable by TimeSpan. Deserialization must not throw (which would break reading the + // entire list); the value is clamped to TimeSpan.MaxValue instead. + string json = "{\"ttlMs\":9999999999999999,\"cacheScope\":\"public\"}"; + + var deserialized = (ICacheableResult)JsonSerializer.Deserialize(json, type, McpJsonUtilities.DefaultOptions)!; + Assert.Equal(TimeSpan.MaxValue, deserialized.TimeToLive); + } + + [Theory] + [MemberData(nameof(CacheableResultTypes))] + public static void CacheableResult_DeserializesLargeNegativeTtl_ClampsToMinValue(Type type) + { + string json = "{\"ttlMs\":-9999999999999999}"; + + var deserialized = (ICacheableResult)JsonSerializer.Deserialize(json, type, McpJsonUtilities.DefaultOptions)!; + Assert.Equal(TimeSpan.MinValue, deserialized.TimeToLive); + } + + [Theory] + [MemberData(nameof(CacheableResultTypes))] + public static void CacheableResult_DeserializesMaxRepresentableTtl_DoesNotThrow(Type type) + { + // The largest whole-millisecond count that fits in a TimeSpan must round-trip without clamping. + long maxWholeMs = long.MaxValue / TimeSpan.TicksPerMillisecond; + string json = $"{{\"ttlMs\":{maxWholeMs}}}"; + + var deserialized = (ICacheableResult)JsonSerializer.Deserialize(json, type, McpJsonUtilities.DefaultOptions)!; + Assert.Equal(TimeSpan.FromTicks(maxWholeMs * TimeSpan.TicksPerMillisecond), deserialized.TimeToLive); + } + + [Theory] + [MemberData(nameof(CacheableResultTypes))] + public static void CacheableResult_DeserializesHugeFloatTtl_ClampsInsteadOfThrowing(Type type) + { + // A fractional/exponent ttlMs whose tick count overflows to +Infinity is clamped to MaxValue + // rather than throwing. (1e400 is beyond double range, so GetDouble() itself returns +Infinity.) + Assert.Equal( + TimeSpan.MaxValue, + DeserializeTtl(type, "{\"ttlMs\":1e400}")); + + // 1e308 is finite but overflows once scaled into tick-space. + Assert.Equal( + TimeSpan.MaxValue, + DeserializeTtl(type, "{\"ttlMs\":1e308}")); + } + + [Theory] + [MemberData(nameof(CacheableResultTypes))] + public static void CacheableResult_DeserializesNegativeInfinityFloatTtl_ClampsToMinValue(Type type) + { + // A large negative exponent ttlMs yields -Infinity from GetDouble(); it must clamp to MinValue, + // not silently become long.MinValue ticks via the cast. + Assert.Equal( + TimeSpan.MinValue, + DeserializeTtl(type, "{\"ttlMs\":-1e400}")); + } + + [Theory] + [MemberData(nameof(CacheableResultTypes))] + public static void CacheableResult_DeserializesUnknownCacheScope_AsNull(Type type) + { + // A future/unknown cacheScope string must not break deserialization of the entire result; it is + // tolerated and surfaced as null (equivalent to an absent field, which clients treat as public). + // Non-string tokens, including objects and arrays, must likewise be tolerated and fully consumed. + foreach (string scope in new[] { "\"shared\"", "\"\"", "123", "true", "null", "{}", "[]", "{\"a\":1}", "[1,2]" }) + { + string json = $"{{\"cacheScope\":{scope}}}"; + + var deserialized = (ICacheableResult)JsonSerializer.Deserialize(json, type, McpJsonUtilities.DefaultOptions)!; + Assert.Null(deserialized.CacheScope); + } + } + + [Theory] + [MemberData(nameof(CacheableResultTypes))] + public static void CacheableResult_DeserializesCacheScope_CaseInsensitively(Type type) + { + // Casing of the security-relevant "private" hint must be honored rather than silently dropped to + // null (which clients treat as public), so matching is case-insensitive on read. + foreach (string scope in new[] { "PUBLIC", "Public", "pUbLiC" }) + { + var result = (ICacheableResult)JsonSerializer.Deserialize($"{{\"cacheScope\":\"{scope}\"}}", type, McpJsonUtilities.DefaultOptions)!; + Assert.Equal(CacheScope.Public, result.CacheScope); + } + + foreach (string scope in new[] { "PRIVATE", "Private", "pRiVaTe" }) + { + var result = (ICacheableResult)JsonSerializer.Deserialize($"{{\"cacheScope\":\"{scope}\"}}", type, McpJsonUtilities.DefaultOptions)!; + Assert.Equal(CacheScope.Private, result.CacheScope); + } + } + + private static TimeSpan? DeserializeTtl(Type type, string json) => + ((ICacheableResult)JsonSerializer.Deserialize(json, type, McpJsonUtilities.DefaultOptions)!).TimeToLive; + + [Theory] + [MemberData(nameof(CacheableResultTypes))] + public static void CacheableResult_DeserializesFractionalTtl(Type type) + { + string json = "{\"ttlMs\":1.5}"; + + var deserialized = (ICacheableResult)JsonSerializer.Deserialize(json, type, McpJsonUtilities.DefaultOptions)!; + Assert.Equal(TimeSpan.FromTicks((long)(1.5 * TimeSpan.TicksPerMillisecond)), deserialized.TimeToLive); + } + + [Fact] + public static void CacheScope_SerializesAsLowercaseStrings() + { + Assert.Equal("\"public\"", JsonSerializer.Serialize(CacheScope.Public, McpJsonUtilities.DefaultOptions)); + Assert.Equal("\"private\"", JsonSerializer.Serialize(CacheScope.Private, McpJsonUtilities.DefaultOptions)); + Assert.Equal(CacheScope.Public, JsonSerializer.Deserialize("\"public\"", McpJsonUtilities.DefaultOptions)); + Assert.Equal(CacheScope.Private, JsonSerializer.Deserialize("\"private\"", McpJsonUtilities.DefaultOptions)); + } + + [Theory] + [MemberData(nameof(CacheableResultTypes))] + public static void CacheableResult_DeserializesTtlWithoutCacheScope(Type type) + { + // ttlMs present, cacheScope absent: the SEP says an absent scope defaults to "public", + // but the SDK only propagates the wire value, so the DTO reports null (caller applies default). + string json = "{\"ttlMs\":1000}"; + + var deserialized = (ICacheableResult)JsonSerializer.Deserialize(json, type, McpJsonUtilities.DefaultOptions)!; + Assert.Equal(TimeSpan.FromSeconds(1), deserialized.TimeToLive); + Assert.Null(deserialized.CacheScope); + } + + [Theory] + [MemberData(nameof(CacheableResultTypes))] + public static void CacheableResult_DeserializesCacheScopeWithoutTtl(Type type) + { + // cacheScope present, ttlMs absent: a server may classify cacheability without a freshness hint. + string json = "{\"cacheScope\":\"private\"}"; + + var deserialized = (ICacheableResult)JsonSerializer.Deserialize(json, type, McpJsonUtilities.DefaultOptions)!; + Assert.Null(deserialized.TimeToLive); + Assert.Equal(CacheScope.Private, deserialized.CacheScope); + } + + [Theory] + [MemberData(nameof(CacheableResultTypes))] + public static void CacheableResult_PaginatedPages_CarryIndependentCachingHints(Type type) + { + // SEP-2549: each paginated page independently carries its own ttlMs/cacheScope. + // Two result instances representing consecutive pages must round-trip distinct hints. + var page1 = (ICacheableResult)Activator.CreateInstance(type)!; + page1.TimeToLive = TimeSpan.FromMinutes(10); + page1.CacheScope = CacheScope.Public; + + var page2 = (ICacheableResult)Activator.CreateInstance(type)!; + page2.TimeToLive = TimeSpan.FromSeconds(5); + page2.CacheScope = CacheScope.Private; + + var rt1 = (ICacheableResult)JsonSerializer.Deserialize( + JsonSerializer.Serialize(page1, type, McpJsonUtilities.DefaultOptions), type, McpJsonUtilities.DefaultOptions)!; + var rt2 = (ICacheableResult)JsonSerializer.Deserialize( + JsonSerializer.Serialize(page2, type, McpJsonUtilities.DefaultOptions), type, McpJsonUtilities.DefaultOptions)!; + + Assert.Equal(TimeSpan.FromMinutes(10), rt1.TimeToLive); + Assert.Equal(CacheScope.Public, rt1.CacheScope); + Assert.Equal(TimeSpan.FromSeconds(5), rt2.TimeToLive); + Assert.Equal(CacheScope.Private, rt2.CacheScope); + } + + [Fact] + public static void CacheableResult_MaxValueTtl_WriteThenRead_IsStableAcrossRoundTrips() + { + // Writing TimeSpan.MaxValue truncates the sub-millisecond remainder to a whole-millisecond + // integer (922337203685477 ms), so the first round-trip is slightly less than MaxValue. + // Critically, once written this value is a fixed point: further round-trips do not drift. + var first = RoundTrip(new ListToolsResult { TimeToLive = TimeSpan.MaxValue }); + var second = RoundTrip(new ListToolsResult { TimeToLive = first.TimeToLive }); + + Assert.NotEqual(TimeSpan.MaxValue, first.TimeToLive); + Assert.Equal(first.TimeToLive, second.TimeToLive); + } + + private static ListToolsResult RoundTrip(ListToolsResult result) => + JsonSerializer.Deserialize( + JsonSerializer.Serialize(result, McpJsonUtilities.DefaultOptions), McpJsonUtilities.DefaultOptions)!; +} diff --git a/tests/ModelContextProtocol.Tests/Protocol/CacheableResultWarningTests.cs b/tests/ModelContextProtocol.Tests/Protocol/CacheableResultWarningTests.cs new file mode 100644 index 000000000..20e55a782 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Protocol/CacheableResultWarningTests.cs @@ -0,0 +1,333 @@ +// Excluded on .NET Framework: the in-memory server helper uses Stream/StreamReader async overloads +// that take a CancellationToken (e.g. StreamReader.ReadLineAsync(CancellationToken) and +// Stream.WriteAsync(ReadOnlyMemory, CancellationToken)) which are not available on net472. +#if !NET472 +using Microsoft.Extensions.Logging; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Tests.Utils; +using System.IO.Pipelines; +using System.Text.Json; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.Tests.Protocol; + +/// +/// Tests for the client-side SEP-2549 conformance warning: when a server that negotiated the 2026-07-28 +/// (or later) protocol version returns a cacheable result (tools/list, prompts/list, resources/list, +/// resources/templates/list, resources/read) without the now-required ttlMs/cacheScope +/// fields, the client logs a warning but never throws. +/// +public class CacheableResultWarningTests : LoggedTest +{ + private const string July2026ProtocolVersion = "2026-07-28"; + private const string OlderProtocolVersion = "2025-11-25"; + + public CacheableResultWarningTests(ITestOutputHelper testOutputHelper) + : base(testOutputHelper) + { + } + + public static IEnumerable CacheableMethods => + [ + [RequestMethods.ToolsList], + [RequestMethods.PromptsList], + [RequestMethods.ResourcesList], + [RequestMethods.ResourcesTemplatesList], + [RequestMethods.ResourcesRead], + ]; + + [Theory] + [MemberData(nameof(CacheableMethods))] + public async Task DraftServerOmittingBothHints_LogsWarning(string method) + { + var (call, result) = GetScenario(method, ttl: null, scope: null); + + await RunScenarioAsync(July2026ProtocolVersion, usePerRequestMetadataLifecycle: true, method, result, call, TestContext.Current.CancellationToken); + + var warning = Assert.Single(MockLoggerProvider.LogMessages, m => + m.LogLevel == LogLevel.Warning && m.Message.Contains(method) && m.Message.Contains("SEP-2549")); + Assert.Contains("ttlMs", warning.Message); + Assert.Contains("cacheScope", warning.Message); + } + + [Fact] + public async Task DraftServerOmittingOnlyCacheScope_WarnsAboutCacheScope() + { + var (call, result) = GetScenario(RequestMethods.ToolsList, ttl: TimeSpan.FromMinutes(5), scope: null); + + await RunScenarioAsync(July2026ProtocolVersion, usePerRequestMetadataLifecycle: true, RequestMethods.ToolsList, result, call, TestContext.Current.CancellationToken); + + var warning = Assert.Single(MockLoggerProvider.LogMessages, m => + m.LogLevel == LogLevel.Warning && m.Message.Contains("SEP-2549")); + Assert.Contains("cacheScope", warning.Message); + Assert.DoesNotContain("ttlMs", warning.Message); + } + + [Fact] + public async Task DraftServerProvidingBothHints_DoesNotWarn() + { + var (call, result) = GetScenario(RequestMethods.ToolsList, ttl: TimeSpan.FromMinutes(5), scope: CacheScope.Public); + + await RunScenarioAsync(July2026ProtocolVersion, usePerRequestMetadataLifecycle: true, RequestMethods.ToolsList, result, call, TestContext.Current.CancellationToken); + + Assert.DoesNotContain(MockLoggerProvider.LogMessages, m => + m.LogLevel == LogLevel.Warning && m.Message.Contains("SEP-2549")); + } + + [Fact] + public async Task OlderServerOmittingHints_DoesNotWarn() + { + // A server on an older protocol version may legitimately omit the fields; no warning should fire. + var (call, result) = GetScenario(RequestMethods.ToolsList, ttl: null, scope: null); + + await RunScenarioAsync(OlderProtocolVersion, usePerRequestMetadataLifecycle: false, RequestMethods.ToolsList, result, call, TestContext.Current.CancellationToken); + + Assert.DoesNotContain(MockLoggerProvider.LogMessages, m => + m.LogLevel == LogLevel.Warning && m.Message.Contains("SEP-2549")); + } + + [Fact] + public async Task AutoPaginatingOverload_DraftServerOmittingHints_LogsWarning() + { + // The auto-paginating convenience overload calls the raw overload per page, so the warning + // fires through that path as well. + var result = JsonSerializer.SerializeToNode( + new ListToolsResult { Tools = [new Tool { Name = "echo" }] }, + McpJsonUtilities.DefaultOptions)!; + + await RunScenarioAsync( + July2026ProtocolVersion, + usePerRequestMetadataLifecycle: true, + RequestMethods.ToolsList, + result, + (c, ct) => c.ListToolsAsync(cancellationToken: ct).AsTask(), + TestContext.Current.CancellationToken); + + Assert.Single(MockLoggerProvider.LogMessages, m => + m.LogLevel == LogLevel.Warning && m.Message.Contains(RequestMethods.ToolsList) && m.Message.Contains("SEP-2549")); + } + + [Fact] + public async Task AutoPaginatingOverload_MultiplePages_WarnsOnlyOncePerMethod() + { + // A non-conformant draft server omits the hints on every page. The warning must be emitted at + // most once per method per session so that long paginated listings do not flood the log. + const int pageCount = 4; + + var clientToServer = new Pipe(); + var serverToClient = new Pipe(); + + var clientTask = McpClient.CreateAsync( + new StreamClientTransport( + clientToServer.Writer.AsStream(), + serverToClient.Reader.AsStream(), + LoggerFactory), + new McpClientOptions { ProtocolVersion = July2026ProtocolVersion }, + loggerFactory: LoggerFactory, + cancellationToken: TestContext.Current.CancellationToken); + + var serverReader = new StreamReader(clientToServer.Reader.AsStream()); + var serverWriter = serverToClient.Writer.AsStream(); + + await PerformHandshakeAsync(serverReader, serverWriter, July2026ProtocolVersion, usePerRequestMetadataLifecycle: true, TestContext.Current.CancellationToken); + + await using var client = await clientTask; + + // Respond to each tools/list page omitting the hints, advancing the cursor until the last page. + var serverLoop = Task.Run(async () => + { + int page = 0; + while (true) + { + var line = await serverReader.ReadLineAsync(TestContext.Current.CancellationToken); + if (line is null) + { + return; + } + + if (JsonSerializer.Deserialize(line, McpJsonUtilities.DefaultOptions) is JsonRpcRequest request && + request.Method == RequestMethods.ToolsList) + { + page++; + var result = new ListToolsResult + { + Tools = [new Tool { Name = $"tool{page}" }], + NextCursor = page < pageCount ? $"page{page}" : null, + }; + + await WriteJsonRpcAsync(serverWriter, new JsonRpcResponse + { + Id = request.Id, + Result = JsonSerializer.SerializeToNode(result, McpJsonUtilities.DefaultOptions), + }, TestContext.Current.CancellationToken); + + if (page >= pageCount) + { + return; + } + } + } + }, TestContext.Current.CancellationToken); + + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + await serverLoop; + + Assert.Equal(pageCount, tools.Count); + Assert.Single(MockLoggerProvider.LogMessages, m => + m.LogLevel == LogLevel.Warning && m.Message.Contains(RequestMethods.ToolsList) && m.Message.Contains("SEP-2549")); + + clientToServer.Writer.Complete(); + serverToClient.Writer.Complete(); + } + + private static (Func Call, JsonNode Result) GetScenario( + string method, TimeSpan? ttl, CacheScope? scope) + { + var options = McpJsonUtilities.DefaultOptions; + return method switch + { + RequestMethods.ToolsList => ( + (c, ct) => c.ListToolsAsync(new ListToolsRequestParams(), ct).AsTask(), + JsonSerializer.SerializeToNode(new ListToolsResult { Tools = [], TimeToLive = ttl, CacheScope = scope }, options)!), + RequestMethods.PromptsList => ( + (c, ct) => c.ListPromptsAsync(new ListPromptsRequestParams(), ct).AsTask(), + JsonSerializer.SerializeToNode(new ListPromptsResult { Prompts = [], TimeToLive = ttl, CacheScope = scope }, options)!), + RequestMethods.ResourcesList => ( + (c, ct) => c.ListResourcesAsync(new ListResourcesRequestParams(), ct).AsTask(), + JsonSerializer.SerializeToNode(new ListResourcesResult { Resources = [], TimeToLive = ttl, CacheScope = scope }, options)!), + RequestMethods.ResourcesTemplatesList => ( + (c, ct) => c.ListResourceTemplatesAsync(new ListResourceTemplatesRequestParams(), ct).AsTask(), + JsonSerializer.SerializeToNode(new ListResourceTemplatesResult { ResourceTemplates = [], TimeToLive = ttl, CacheScope = scope }, options)!), + RequestMethods.ResourcesRead => ( + (c, ct) => c.ReadResourceAsync(new ReadResourceRequestParams { Uri = "test://resource" }, ct).AsTask(), + JsonSerializer.SerializeToNode(new ReadResourceResult { Contents = [], TimeToLive = ttl, CacheScope = scope }, options)!), + _ => throw new ArgumentOutOfRangeException(nameof(method), method, "Unhandled method."), + }; + } + + private async Task RunScenarioAsync( + string serverProtocolVersion, + bool usePerRequestMetadataLifecycle, + string method, + JsonNode resultNode, + Func clientCall, + CancellationToken cancellationToken) + { + var clientToServer = new Pipe(); + var serverToClient = new Pipe(); + + // Pin the protocol version so the client deterministically takes the per-request metadata + // (server/discover) lifecycle for 2026-07-28 and the initialize lifecycle for older versions. + var clientTask = McpClient.CreateAsync( + new StreamClientTransport( + clientToServer.Writer.AsStream(), + serverToClient.Reader.AsStream(), + LoggerFactory), + new McpClientOptions { ProtocolVersion = serverProtocolVersion }, + loggerFactory: LoggerFactory, + cancellationToken: cancellationToken); + + var serverReader = new StreamReader(clientToServer.Reader.AsStream()); + var serverWriter = serverToClient.Writer.AsStream(); + + await PerformHandshakeAsync(serverReader, serverWriter, serverProtocolVersion, usePerRequestMetadataLifecycle, cancellationToken); + + await using var client = await clientTask; + Assert.Equal(serverProtocolVersion, client.NegotiatedProtocolVersion); + + // Background server loop: respond to the target request with the crafted result. + var serverLoop = Task.Run(async () => + { + while (true) + { + var line = await serverReader.ReadLineAsync(cancellationToken); + if (line is null) + { + return; + } + + if (JsonSerializer.Deserialize(line, McpJsonUtilities.DefaultOptions) is JsonRpcRequest request && + request.Method == method) + { + await WriteJsonRpcAsync(serverWriter, new JsonRpcResponse + { + Id = request.Id, + Result = resultNode, + }, cancellationToken); + return; + } + } + }, cancellationToken); + + await clientCall(client, cancellationToken); + await serverLoop; + + clientToServer.Writer.Complete(); + serverToClient.Writer.Complete(); + } + + private static async Task PerformHandshakeAsync( + StreamReader serverReader, + Stream serverWriter, + string serverProtocolVersion, + bool usePerRequestMetadataLifecycle, + CancellationToken cancellationToken) + { + var requestLine = await serverReader.ReadLineAsync(cancellationToken); + Assert.NotNull(requestLine); + var request = JsonSerializer.Deserialize(requestLine, McpJsonUtilities.DefaultOptions); + Assert.NotNull(request); + + if (usePerRequestMetadataLifecycle) + { + // Per-request metadata lifecycle (SEP-2575): no initialize handshake. The client probes + // server/discover to learn capabilities, then sends normal RPCs carrying per-request _meta. + Assert.Equal(RequestMethods.ServerDiscover, request.Method); + + await WriteJsonRpcAsync(serverWriter, new JsonRpcResponse + { + Id = request.Id, + Result = JsonSerializer.SerializeToNode(new DiscoverResult + { + SupportedVersions = [serverProtocolVersion], + Capabilities = new ServerCapabilities(), + Meta = new JsonObject + { + [MetaKeys.ServerInfo] = JsonSerializer.SerializeToNode(new Implementation { Name = "MockServer", Version = "1.0" }, McpJsonUtilities.DefaultOptions), + }, + }, McpJsonUtilities.DefaultOptions), + }, cancellationToken); + } + else + { + // Initialize handshake for older protocol versions. + Assert.Equal(RequestMethods.Initialize, request.Method); + + await WriteJsonRpcAsync(serverWriter, new JsonRpcResponse + { + Id = request.Id, + Result = JsonSerializer.SerializeToNode(new InitializeResult + { + ProtocolVersion = serverProtocolVersion, + Capabilities = new ServerCapabilities(), + ServerInfo = new Implementation { Name = "MockServer", Version = "1.0" }, + }, McpJsonUtilities.DefaultOptions), + }, cancellationToken); + + // Consume the initialized notification. + var initializedLine = await serverReader.ReadLineAsync(cancellationToken); + Assert.NotNull(initializedLine); + } + } + + private static async Task WriteJsonRpcAsync(Stream writer, JsonRpcMessage message, CancellationToken cancellationToken) + { + var bytes = JsonSerializer.SerializeToUtf8Bytes(message, McpJsonUtilities.DefaultOptions); + await writer.WriteAsync(bytes, cancellationToken); + await writer.WriteAsync("\n"u8.ToArray(), cancellationToken); + await writer.FlushAsync(cancellationToken); + } +} + +#endif diff --git a/tests/ModelContextProtocol.Tests/Protocol/CallToolRequestParamsTests.cs b/tests/ModelContextProtocol.Tests/Protocol/CallToolRequestParamsTests.cs index d2f5a09ad..ec758120f 100644 --- a/tests/ModelContextProtocol.Tests/Protocol/CallToolRequestParamsTests.cs +++ b/tests/ModelContextProtocol.Tests/Protocol/CallToolRequestParamsTests.cs @@ -17,7 +17,6 @@ public static void CallToolRequestParams_SerializationRoundTrip_PreservesAllProp ["city"] = JsonDocument.Parse("\"Seattle\"").RootElement.Clone(), ["units"] = JsonDocument.Parse("\"metric\"").RootElement.Clone() }, - Task = new McpTaskMetadata { TimeToLive = TimeSpan.FromHours(1) }, Meta = new JsonObject { ["progressToken"] = "token-123" } }; @@ -30,8 +29,6 @@ public static void CallToolRequestParams_SerializationRoundTrip_PreservesAllProp Assert.Equal(2, deserialized.Arguments.Count); Assert.Equal("Seattle", deserialized.Arguments["city"].GetString()); Assert.Equal("metric", deserialized.Arguments["units"].GetString()); - Assert.NotNull(deserialized.Task); - Assert.Equal(original.Task.TimeToLive, deserialized.Task.TimeToLive); Assert.NotNull(deserialized.Meta); Assert.Equal("token-123", (string)deserialized.Meta["progressToken"]!); } @@ -50,7 +47,6 @@ public static void CallToolRequestParams_SerializationRoundTrip_WithMinimalPrope Assert.NotNull(deserialized); Assert.Equal(original.Name, deserialized.Name); Assert.Null(deserialized.Arguments); - Assert.Null(deserialized.Task); Assert.Null(deserialized.Meta); } } diff --git a/tests/ModelContextProtocol.Tests/Protocol/CallToolResultTests.cs b/tests/ModelContextProtocol.Tests/Protocol/CallToolResultTests.cs index d66e03b3f..7dca60040 100644 --- a/tests/ModelContextProtocol.Tests/Protocol/CallToolResultTests.cs +++ b/tests/ModelContextProtocol.Tests/Protocol/CallToolResultTests.cs @@ -1,4 +1,5 @@ using ModelContextProtocol.Protocol; +using System.Text; using System.Text.Json; using System.Text.Json.Nodes; @@ -14,13 +15,6 @@ public static void CallToolResult_SerializationRoundTrip_PreservesAllProperties( Content = [new TextContentBlock { Text = "Result text" }], StructuredContent = JsonElement.Parse("""{"temperature":72}"""), IsError = false, - Task = new McpTask - { - TaskId = "task-1", - Status = McpTaskStatus.Completed, - CreatedAt = new DateTimeOffset(2025, 1, 1, 0, 0, 0, TimeSpan.Zero), - LastUpdatedAt = new DateTimeOffset(2025, 1, 1, 0, 0, 0, TimeSpan.Zero) - }, Meta = new JsonObject { ["key"] = "value" } }; @@ -34,8 +28,6 @@ public static void CallToolResult_SerializationRoundTrip_PreservesAllProperties( Assert.NotNull(deserialized.StructuredContent); Assert.Equal(72, deserialized.StructuredContent.Value.GetProperty("temperature").GetInt32()); Assert.False(deserialized.IsError); - Assert.NotNull(deserialized.Task); - Assert.Equal("task-1", deserialized.Task.TaskId); Assert.NotNull(deserialized.Meta); Assert.Equal("value", (string)deserialized.Meta["key"]!); } @@ -52,7 +44,44 @@ public static void CallToolResult_SerializationRoundTrip_WithMinimalProperties() Assert.Empty(deserialized.Content); Assert.Null(deserialized.StructuredContent); Assert.Null(deserialized.IsError); - Assert.Null(deserialized.Task); Assert.Null(deserialized.Meta); } + + [Fact] + public static void CallToolResult_SerializationRoundTrip_PreservesEmbeddedPdfResource() + { + byte[] pdfBytes = Encoding.ASCII.GetBytes("%PDF-1.7\n"); + var original = new CallToolResult + { + Content = + [ + new EmbeddedResourceBlock + { + Resource = BlobResourceContents.FromBytes( + pdfBytes, + "file:///mypdf.pdf", + "application/pdf") + } + ] + }; + + string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); + + using JsonDocument document = JsonDocument.Parse(json); + JsonElement resourceBlock = document.RootElement.GetProperty("content")[0]; + Assert.Equal("resource", resourceBlock.GetProperty("type").GetString()); + + JsonElement resource = resourceBlock.GetProperty("resource"); + Assert.Equal("file:///mypdf.pdf", resource.GetProperty("uri").GetString()); + Assert.Equal("application/pdf", resource.GetProperty("mimeType").GetString()); + Assert.Equal(Convert.ToBase64String(pdfBytes), resource.GetProperty("blob").GetString()); + + var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); + Assert.NotNull(deserialized); + var embeddedResource = Assert.IsType(Assert.Single(deserialized.Content)); + var pdfResource = Assert.IsType(embeddedResource.Resource); + Assert.Equal("file:///mypdf.pdf", pdfResource.Uri); + Assert.Equal("application/pdf", pdfResource.MimeType); + Assert.Equal(pdfBytes, pdfResource.DecodedData.ToArray()); + } } diff --git a/tests/ModelContextProtocol.Tests/Protocol/CancelMcpTaskRequestParamsTests.cs b/tests/ModelContextProtocol.Tests/Protocol/CancelMcpTaskRequestParamsTests.cs deleted file mode 100644 index a3b3b2ef6..000000000 --- a/tests/ModelContextProtocol.Tests/Protocol/CancelMcpTaskRequestParamsTests.cs +++ /dev/null @@ -1,25 +0,0 @@ -using ModelContextProtocol.Protocol; -using System.Text.Json; - -namespace ModelContextProtocol.Tests.Protocol; - -public static class CancelMcpTaskRequestParamsTests -{ - [Fact] - public static void CancelMcpTaskRequestParams_SerializationRoundTrip() - { - // Arrange - var original = new CancelMcpTaskRequestParams - { - TaskId = "cancel-task-456" - }; - - // Act - string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); - var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); - - // Assert - Assert.NotNull(deserialized); - Assert.Equal(original.TaskId, deserialized.TaskId); - } -} diff --git a/tests/ModelContextProtocol.Tests/Protocol/CancelMcpTaskResultTests.cs b/tests/ModelContextProtocol.Tests/Protocol/CancelMcpTaskResultTests.cs deleted file mode 100644 index 5cf628642..000000000 --- a/tests/ModelContextProtocol.Tests/Protocol/CancelMcpTaskResultTests.cs +++ /dev/null @@ -1,33 +0,0 @@ -using ModelContextProtocol.Protocol; -using System.Text.Json; - -namespace ModelContextProtocol.Tests.Protocol; - -public static class CancelMcpTaskResultTests -{ - [Fact] - public static void CancelMcpTaskResult_SerializationRoundTrip() - { - // Arrange - var original = new CancelMcpTaskResult - { - TaskId = "cancelled-789", - Status = McpTaskStatus.Cancelled, - StatusMessage = "Cancelled by user", - CreatedAt = DateTimeOffset.UtcNow, - LastUpdatedAt = DateTimeOffset.UtcNow, - TimeToLive = null, - PollInterval = null - }; - - // Act - string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); - var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); - - // Assert - Assert.NotNull(deserialized); - Assert.Equal(original.TaskId, deserialized.TaskId); - Assert.Equal(original.Status, deserialized.Status); - Assert.Equal(original.StatusMessage, deserialized.StatusMessage); - } -} diff --git a/tests/ModelContextProtocol.Tests/Protocol/CancellationTests.cs b/tests/ModelContextProtocol.Tests/Protocol/CancellationTests.cs index ac40bd767..614af34c7 100644 --- a/tests/ModelContextProtocol.Tests/Protocol/CancellationTests.cs +++ b/tests/ModelContextProtocol.Tests/Protocol/CancellationTests.cs @@ -84,6 +84,9 @@ public async Task InitializeTimeout_DoesNotSendCancellationNotification() var clientOptions = new McpClientOptions { + // Pin to a legacy protocol version so the client performs the initialize handshake + // (the spec rule under test is "the initialize request MUST NOT be cancelled by clients"). + ProtocolVersion = "2025-11-25", InitializationTimeout = TimeSpan.FromMilliseconds(500), }; diff --git a/tests/ModelContextProtocol.Tests/Protocol/ClientCapabilitiesTests.cs b/tests/ModelContextProtocol.Tests/Protocol/ClientCapabilitiesTests.cs index cacb7e84e..82613dd53 100644 --- a/tests/ModelContextProtocol.Tests/Protocol/ClientCapabilitiesTests.cs +++ b/tests/ModelContextProtocol.Tests/Protocol/ClientCapabilitiesTests.cs @@ -21,7 +21,6 @@ public static void ClientCapabilities_SerializationRoundTrip_PreservesAllPropert Form = new FormElicitationCapability(), Url = new UrlElicitationCapability() }, - Tasks = new McpTasksCapability(), Extensions = new Dictionary { ["io.modelcontextprotocol/test"] = new object() @@ -40,7 +39,6 @@ public static void ClientCapabilities_SerializationRoundTrip_PreservesAllPropert Assert.NotNull(deserialized.Elicitation); Assert.NotNull(deserialized.Elicitation.Form); Assert.NotNull(deserialized.Elicitation.Url); - Assert.NotNull(deserialized.Tasks); Assert.NotNull(deserialized.Extensions); Assert.True(deserialized.Extensions.ContainsKey("io.modelcontextprotocol/test")); } @@ -58,7 +56,6 @@ public static void ClientCapabilities_SerializationRoundTrip_WithMinimalProperti Assert.Null(deserialized.Roots); Assert.Null(deserialized.Sampling); Assert.Null(deserialized.Elicitation); - Assert.Null(deserialized.Tasks); Assert.Null(deserialized.Extensions); } diff --git a/tests/ModelContextProtocol.Tests/Protocol/CreateTaskResultTests.cs b/tests/ModelContextProtocol.Tests/Protocol/CreateTaskResultTests.cs deleted file mode 100644 index 0252053cb..000000000 --- a/tests/ModelContextProtocol.Tests/Protocol/CreateTaskResultTests.cs +++ /dev/null @@ -1,41 +0,0 @@ -using ModelContextProtocol.Protocol; -using System.Text.Json; -using System.Text.Json.Nodes; - -namespace ModelContextProtocol.Tests.Protocol; - -public static class CreateTaskResultTests -{ - [Fact] - public static void CreateTaskResult_SerializationRoundTrip_PreservesAllProperties() - { - var original = new CreateTaskResult - { - Task = new McpTask - { - TaskId = "task-123", - Status = McpTaskStatus.Working, - StatusMessage = "Processing", - CreatedAt = new DateTimeOffset(2025, 6, 1, 12, 0, 0, TimeSpan.Zero), - LastUpdatedAt = new DateTimeOffset(2025, 6, 1, 12, 5, 0, TimeSpan.Zero), - TimeToLive = TimeSpan.FromHours(1), - PollInterval = TimeSpan.FromSeconds(5) - }, - Meta = new JsonObject { ["key"] = "value" } - }; - - string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); - var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); - - Assert.NotNull(deserialized); - Assert.Equal("task-123", deserialized.Task.TaskId); - Assert.Equal(McpTaskStatus.Working, deserialized.Task.Status); - Assert.Equal("Processing", deserialized.Task.StatusMessage); - Assert.Equal(original.Task.CreatedAt, deserialized.Task.CreatedAt); - Assert.Equal(original.Task.LastUpdatedAt, deserialized.Task.LastUpdatedAt); - Assert.Equal(original.Task.TimeToLive, deserialized.Task.TimeToLive); - Assert.Equal(original.Task.PollInterval, deserialized.Task.PollInterval); - Assert.NotNull(deserialized.Meta); - Assert.Equal("value", (string)deserialized.Meta["key"]!); - } -} diff --git a/tests/ModelContextProtocol.Tests/Protocol/DiscoverProtocolTests.cs b/tests/ModelContextProtocol.Tests/Protocol/DiscoverProtocolTests.cs new file mode 100644 index 000000000..b225dd600 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Protocol/DiscoverProtocolTests.cs @@ -0,0 +1,77 @@ +using ModelContextProtocol.Protocol; +using System.Text.Json; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.Tests.Protocol; + +/// +/// Serialization tests for the request/result types introduced by the 2026-07-28 protocol revision (SEP-2575). +/// +public static class DiscoverProtocolTests +{ + [Fact] + public static void DiscoverRequestParams_SerializationRoundTrip_WithMeta() + { + var original = new DiscoverRequestParams + { + Meta = new JsonObject + { + [MetaKeys.ProtocolVersion] = "2026-07-28", + [MetaKeys.ClientInfo] = new JsonObject + { + ["name"] = "test-client", + ["version"] = "1.0", + }, + [MetaKeys.ClientCapabilities] = new JsonObject(), + }, + }; + + var json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); + var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); + + Assert.NotNull(deserialized); + Assert.NotNull(deserialized.Meta); + Assert.Equal("2026-07-28", (string)deserialized.Meta[MetaKeys.ProtocolVersion]!); + } + + [Fact] + public static void DiscoverResult_SerializationRoundTrip_PreservesAllProperties() + { + var original = new DiscoverResult + { + SupportedVersions = new List { "2025-11-25", "2026-07-28" }, + Capabilities = new ServerCapabilities + { + Tools = new ToolsCapability { ListChanged = true }, + }, + Instructions = "Use this server for testing.", + }; + + var json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); + var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); + + Assert.NotNull(deserialized); + Assert.Equal(["2025-11-25", "2026-07-28"], deserialized.SupportedVersions); + Assert.NotNull(deserialized.Capabilities.Tools); + Assert.True(deserialized.Capabilities.Tools.ListChanged); + Assert.Equal("Use this server for testing.", deserialized.Instructions); + } + + [Fact] + public static void DiscoverResult_SerializationRoundTrip_WithMinimalProperties() + { + var original = new DiscoverResult + { + SupportedVersions = new List { "2026-07-28" }, + Capabilities = new ServerCapabilities(), + }; + + var json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); + var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); + + Assert.NotNull(deserialized); + Assert.Single(deserialized.SupportedVersions); + Assert.Equal("2026-07-28", deserialized.SupportedVersions[0]); + Assert.Null(deserialized.Instructions); + } +} diff --git a/tests/ModelContextProtocol.Tests/Protocol/DiscoverResultCacheableTests.cs b/tests/ModelContextProtocol.Tests/Protocol/DiscoverResultCacheableTests.cs new file mode 100644 index 000000000..0670f61b8 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Protocol/DiscoverResultCacheableTests.cs @@ -0,0 +1,124 @@ +using ModelContextProtocol.Protocol; +using System.Text.Json; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.Tests.Protocol; + +/// +/// Targeted tests for the SEP-2549 caching hints (ttlMs and cacheScope) on +/// . Spec PR #2855 promotes both fields to required on the discover +/// response. has required CLR properties for +/// and , +/// which prevents reuse of the parameterized +/// helper (it instantiates via reflection). This file covers the +/// same property-shape assertions for . +/// +public static class DiscoverResultCacheableTests +{ + private static DiscoverResult NewDiscoverResult() => new() + { + SupportedVersions = [McpProtocolVersions.November2025ProtocolVersion, McpProtocolVersions.July2026ProtocolVersion], + Capabilities = new ServerCapabilities(), + }; + + [Fact] + public static void DiscoverResult_SerializesTtlMsAsIntegerMilliseconds() + { + var result = NewDiscoverResult(); + result.TimeToLive = TimeSpan.FromMilliseconds(300_000); + result.CacheScope = CacheScope.Public; + + string json = JsonSerializer.Serialize(result, McpJsonUtilities.DefaultOptions); + var node = JsonNode.Parse(json)!.AsObject(); + + Assert.True(node.ContainsKey("ttlMs")); + Assert.Equal(JsonValueKind.Number, node["ttlMs"]!.GetValueKind()); + Assert.Equal(300_000, node["ttlMs"]!.GetValue()); + Assert.Equal("public", node["cacheScope"]!.GetValue()); + + var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions)!; + Assert.Equal(TimeSpan.FromMilliseconds(300_000), deserialized.TimeToLive); + Assert.Equal(CacheScope.Public, deserialized.CacheScope); + } + + [Fact] + public static void DiscoverResult_PrivateScope_RoundTrips() + { + var result = NewDiscoverResult(); + result.TimeToLive = TimeSpan.Zero; + result.CacheScope = CacheScope.Private; + + string json = JsonSerializer.Serialize(result, McpJsonUtilities.DefaultOptions); + var node = JsonNode.Parse(json)!.AsObject(); + + Assert.True(node.ContainsKey("ttlMs")); + Assert.Equal(0, node["ttlMs"]!.GetValue()); + Assert.Equal("private", node["cacheScope"]!.GetValue()); + + var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions)!; + Assert.Equal(TimeSpan.Zero, deserialized.TimeToLive); + Assert.Equal(CacheScope.Private, deserialized.CacheScope); + } + + [Fact] + public static void DiscoverResult_OmitsCachingHints_WhenUnset() + { + var result = NewDiscoverResult(); + + string json = JsonSerializer.Serialize(result, McpJsonUtilities.DefaultOptions); + var node = JsonNode.Parse(json)!.AsObject(); + + // Backward compatibility: servers that do not set the hints must not emit them. + Assert.False(node.ContainsKey("ttlMs")); + Assert.False(node.ContainsKey("cacheScope")); + + var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions)!; + Assert.Null(deserialized.TimeToLive); + Assert.Null(deserialized.CacheScope); + } + + [Fact] + public static void DiscoverResult_DeserializesMissingHints_AsNull() + { + // A response from a pre-PR-#2855 server may omit both fields. Deserialization must succeed + // and surface them as null so callers can apply their own defaults. + string json = + """ + { + "supportedVersions": ["2025-11-25"], + "capabilities": {}, + "serverInfo": {"name": "x", "version": "1"} + } + """; + + var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions)!; + Assert.Null(deserialized.TimeToLive); + Assert.Null(deserialized.CacheScope); + } + + [Fact] + public static void DiscoverResult_DeserializesUnknownCacheScope_AsNull() + { + // A future or unknown cacheScope string must not break deserialization of the entire result. + string json = + """ + { + "supportedVersions": ["2025-11-25"], + "capabilities": {}, + "serverInfo": {"name": "x", "version": "1"}, + "cacheScope": "shared" + } + """; + + var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions)!; + Assert.Null(deserialized.CacheScope); + } + + [Fact] + public static void DiscoverResult_ImplementsICacheableResult() + { + // Compile-time assertion that DiscoverResult participates in the shared cacheability surface + // alongside the list/read result types. + Assert.IsAssignableFrom(NewDiscoverResult()); + } +} diff --git a/tests/ModelContextProtocol.Tests/Protocol/ElicitRequestParamsTests.cs b/tests/ModelContextProtocol.Tests/Protocol/ElicitRequestParamsTests.cs index 1d57f55ad..f8e2fedbf 100644 --- a/tests/ModelContextProtocol.Tests/Protocol/ElicitRequestParamsTests.cs +++ b/tests/ModelContextProtocol.Tests/Protocol/ElicitRequestParamsTests.cs @@ -23,7 +23,6 @@ public static void ElicitRequestParams_SerializationRoundTrip_PreservesAllProper ["age"] = new ElicitRequestParams.NumberSchema { Description = "Your age" } } }, - Task = new McpTaskMetadata { TimeToLive = TimeSpan.FromMinutes(10) }, Meta = new JsonObject { ["progressToken"] = "tok-1" } }; @@ -37,8 +36,6 @@ public static void ElicitRequestParams_SerializationRoundTrip_PreservesAllProper Assert.Equal("Please provide your details", deserialized.Message); Assert.NotNull(deserialized.RequestedSchema); Assert.Equal(2, deserialized.RequestedSchema.Properties.Count); - Assert.NotNull(deserialized.Task); - Assert.Equal(TimeSpan.FromMinutes(10), deserialized.Task.TimeToLive); Assert.NotNull(deserialized.Meta); Assert.Equal("tok-1", (string)deserialized.Meta["progressToken"]!); } @@ -63,7 +60,6 @@ public static void ElicitRequestParams_SerializationRoundTrip_UrlMode() Assert.Equal("https://example.com/auth", deserialized.Url); Assert.Equal("Please authenticate", deserialized.Message); Assert.Null(deserialized.RequestedSchema); - Assert.Null(deserialized.Task); } [Fact] @@ -83,7 +79,6 @@ public static void ElicitRequestParams_SerializationRoundTrip_WithMinimalPropert Assert.Null(deserialized.ElicitationId); Assert.Null(deserialized.Url); Assert.Null(deserialized.RequestedSchema); - Assert.Null(deserialized.Task); Assert.Null(deserialized.Meta); } } diff --git a/tests/ModelContextProtocol.Tests/Protocol/ElicitationTypedTests.cs b/tests/ModelContextProtocol.Tests/Protocol/ElicitationTypedTests.cs index 7b55b738a..60b8093a7 100644 --- a/tests/ModelContextProtocol.Tests/Protocol/ElicitationTypedTests.cs +++ b/tests/ModelContextProtocol.Tests/Protocol/ElicitationTypedTests.cs @@ -287,6 +287,8 @@ public async Task Elicit_Typed_With_Nullable_Property_Type_Throws() var ex = await Assert.ThrowsAsync(async () => await client.CallToolAsync("TestElicitationNullablePropertyForm", cancellationToken: TestContext.Current.CancellationToken)); + + Assert.Contains("Nullable", ex.Message); } [Fact] @@ -340,7 +342,7 @@ public sealed class CamelForm public sealed class NullablePropertyForm { public string? FirstName { get; set; } - public int ZipCode { get; set; } + public int? ZipCode { get; set; } public bool IsAdmin { get; set; } } diff --git a/tests/ModelContextProtocol.Tests/Protocol/GetTaskPayloadRequestParamsTests.cs b/tests/ModelContextProtocol.Tests/Protocol/GetTaskPayloadRequestParamsTests.cs deleted file mode 100644 index 47f427259..000000000 --- a/tests/ModelContextProtocol.Tests/Protocol/GetTaskPayloadRequestParamsTests.cs +++ /dev/null @@ -1,25 +0,0 @@ -using ModelContextProtocol.Protocol; -using System.Text.Json; - -namespace ModelContextProtocol.Tests.Protocol; - -public static class GetTaskPayloadRequestParamsTests -{ - [Fact] - public static void GetTaskPayloadRequestParams_SerializationRoundTrip() - { - // Arrange - var original = new GetTaskPayloadRequestParams - { - TaskId = "payload-task-999" - }; - - // Act - string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); - var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); - - // Assert - Assert.NotNull(deserialized); - Assert.Equal(original.TaskId, deserialized.TaskId); - } -} diff --git a/tests/ModelContextProtocol.Tests/Protocol/GetTaskRequestParamsTests.cs b/tests/ModelContextProtocol.Tests/Protocol/GetTaskRequestParamsTests.cs deleted file mode 100644 index 9b3e7b1d5..000000000 --- a/tests/ModelContextProtocol.Tests/Protocol/GetTaskRequestParamsTests.cs +++ /dev/null @@ -1,25 +0,0 @@ -using ModelContextProtocol.Protocol; -using System.Text.Json; - -namespace ModelContextProtocol.Tests.Protocol; - -public static class GetTaskRequestParamsTests -{ - [Fact] - public static void GetTaskRequestParams_SerializationRoundTrip() - { - // Arrange - var original = new GetTaskRequestParams - { - TaskId = "get-task-123" - }; - - // Act - string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); - var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); - - // Assert - Assert.NotNull(deserialized); - Assert.Equal(original.TaskId, deserialized.TaskId); - } -} diff --git a/tests/ModelContextProtocol.Tests/Protocol/GetTaskResultTests.cs b/tests/ModelContextProtocol.Tests/Protocol/GetTaskResultTests.cs deleted file mode 100644 index ece58683f..000000000 --- a/tests/ModelContextProtocol.Tests/Protocol/GetTaskResultTests.cs +++ /dev/null @@ -1,37 +0,0 @@ -using ModelContextProtocol.Protocol; -using System.Text.Json; - -namespace ModelContextProtocol.Tests.Protocol; - -public static class GetTaskResultTests -{ - [Fact] - public static void GetTaskResult_SerializationRoundTrip() - { - // Arrange - var original = new GetTaskResult - { - TaskId = "result-123", - Status = McpTaskStatus.Completed, - StatusMessage = "Done", - CreatedAt = DateTimeOffset.UtcNow, - LastUpdatedAt = DateTimeOffset.UtcNow, - TimeToLive = TimeSpan.FromHours(1), - PollInterval = TimeSpan.FromSeconds(1) - }; - - // Act - string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); - var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); - - // Assert - Assert.NotNull(deserialized); - Assert.Equal(original.TaskId, deserialized.TaskId); - Assert.Equal(original.Status, deserialized.Status); - Assert.Equal(original.StatusMessage, deserialized.StatusMessage); - Assert.Equal(original.CreatedAt, deserialized.CreatedAt); - Assert.Equal(original.LastUpdatedAt, deserialized.LastUpdatedAt); - Assert.Equal(original.TimeToLive, deserialized.TimeToLive); - Assert.Equal(original.PollInterval, deserialized.PollInterval); - } -} diff --git a/tests/ModelContextProtocol.Tests/Protocol/JsonRpcMessageConverterTests.cs b/tests/ModelContextProtocol.Tests/Protocol/JsonRpcMessageConverterTests.cs index ddab6b142..c23d34bf6 100644 --- a/tests/ModelContextProtocol.Tests/Protocol/JsonRpcMessageConverterTests.cs +++ b/tests/ModelContextProtocol.Tests/Protocol/JsonRpcMessageConverterTests.cs @@ -760,4 +760,71 @@ public static void Deserialize_ErrorWithArrayData_IsValid() var error = (JsonRpcError)message; Assert.NotNull(error.Error.Data); } + + [Fact] + public static void Deserialize_ErrorWithNullId_IsValid() + { + // Per JSON-RPC 2.0 §5.1, when an error occurs before the request id can be determined + // (parse error or invalid request), the server MUST respond with id=null. This shape is + // produced by some peers (e.g. Python's simple-streamablehttp-stateless on a 2026-07-28 probe) + // and must be accepted so the HTTP-fallback path can recognize the structured signal. + string json = """{"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"Bad Request"}}"""; + + var message = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); + + Assert.NotNull(message); + var error = Assert.IsType(message); + Assert.Equal(default(RequestId), error.Id); + Assert.Equal(-32600, error.Error.Code); + Assert.Equal("Bad Request", error.Error.Message); + } + + [Fact] + public static void Deserialize_ErrorWithMissingId_IsValid() + { + // Some peers omit `id` entirely on pre-routing errors; treat as null per JSON-RPC 2.0 §5.1. + string json = """{"jsonrpc":"2.0","error":{"code":-32700,"message":"Parse error"}}"""; + + var message = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); + + Assert.NotNull(message); + var error = Assert.IsType(message); + Assert.Equal(default(RequestId), error.Id); + Assert.Equal(-32700, error.Error.Code); + } + + [Fact] + public static void Deserialize_RequestWithExplicitNullId_Throws() + { + // A message carrying a `method` and an explicit `id:null` is a malformed request. Per the MCP + // base protocol the request id "MUST NOT be null", and a null id does NOT denote a notification + // (JSON-RPC 2.0 notifications omit the id member entirely). The converter must reject it rather + // than silently downgrading to a notification (which would swallow the id and skip the response). + string json = """{"jsonrpc":"2.0","id":null,"method":"tools/list"}"""; + + Assert.Throws(() => + JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions)); + } + + [Fact] + public static void Deserialize_RequestWithExplicitNullIdAndParams_Throws() + { + string json = """{"jsonrpc":"2.0","id":null,"method":"tools/call","params":{"name":"echo"}}"""; + + Assert.Throws(() => + JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions)); + } + + [Fact] + public static void Deserialize_NotificationWithoutIdMember_IsNotConfusedWithNullIdRequest() + { + // Contrast with the explicit-null-id case above: omitting the id member entirely is a valid + // notification and must continue to deserialize as one. + string json = """{"jsonrpc":"2.0","method":"notifications/cancelled","params":{"requestId":1}}"""; + + var message = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); + + var notification = Assert.IsType(message); + Assert.Equal("notifications/cancelled", notification.Method); + } } diff --git a/tests/ModelContextProtocol.Tests/Protocol/July2026ProtocolErrorDataTests.cs b/tests/ModelContextProtocol.Tests/Protocol/July2026ProtocolErrorDataTests.cs new file mode 100644 index 000000000..88e3e5644 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Protocol/July2026ProtocolErrorDataTests.cs @@ -0,0 +1,67 @@ +using ModelContextProtocol.Protocol; +using System.Text.Json; + +namespace ModelContextProtocol.Tests.Protocol; + +/// +/// Serialization tests for the error data payloads introduced by the 2026-07-28 protocol revision (SEP-2575). +/// +public static class July2026ProtocolErrorDataTests +{ + [Fact] + public static void UnsupportedProtocolVersionErrorData_SerializationRoundTrip_PreservesAllProperties() + { + var original = new UnsupportedProtocolVersionErrorData + { + Supported = new List { "2024-11-05", "2025-03-26", "2025-06-18", "2025-11-25" }, + Requested = "2026-07-28", + }; + + var json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); + var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); + + Assert.NotNull(deserialized); + Assert.Equal(4, deserialized.Supported.Count); + Assert.Contains("2025-11-25", deserialized.Supported); + Assert.Equal("2026-07-28", deserialized.Requested); + } + + [Fact] + public static void MissingRequiredClientCapabilityErrorData_SerializationRoundTrip_PreservesAllProperties() + { + var original = new MissingRequiredClientCapabilityErrorData + { + RequiredCapabilities = new ClientCapabilities + { + Sampling = new SamplingCapability(), + }, + }; + + var json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); + var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); + + Assert.NotNull(deserialized); + Assert.NotNull(deserialized.RequiredCapabilities.Sampling); + } + + [Fact] + public static void UnsupportedProtocolVersionException_ExposesRequestedAndSupported() + { + var ex = new UnsupportedProtocolVersionException("2099-12-31", ["2025-11-25", "2025-06-18"]); + + Assert.Equal(McpErrorCode.UnsupportedProtocolVersion, ex.ErrorCode); + Assert.Equal("2099-12-31", ex.Requested); + Assert.Equal(2, ex.Supported.Count); + Assert.Contains("2025-11-25", ex.Supported); + } + + [Fact] + public static void MissingRequiredClientCapabilityException_ExposesRequiredCapabilities() + { + var caps = new ClientCapabilities { Roots = new RootsCapability() }; + var ex = new MissingRequiredClientCapabilityException(caps); + + Assert.Equal(McpErrorCode.MissingRequiredClientCapability, ex.ErrorCode); + Assert.Same(caps, ex.RequiredCapabilities); + } +} diff --git a/tests/ModelContextProtocol.Tests/Protocol/ListTasksRequestParamsTests.cs b/tests/ModelContextProtocol.Tests/Protocol/ListTasksRequestParamsTests.cs deleted file mode 100644 index 3e9022757..000000000 --- a/tests/ModelContextProtocol.Tests/Protocol/ListTasksRequestParamsTests.cs +++ /dev/null @@ -1,25 +0,0 @@ -using ModelContextProtocol.Protocol; -using System.Text.Json; - -namespace ModelContextProtocol.Tests.Protocol; - -public static class ListTasksRequestParamsTests -{ - [Fact] - public static void ListTasksRequestParams_SerializationRoundTrip() - { - // Arrange - var original = new ListTasksRequestParams - { - Cursor = "cursor-abc123" - }; - - // Act - string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); - var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); - - // Assert - Assert.NotNull(deserialized); - Assert.Equal(original.Cursor, deserialized.Cursor); - } -} diff --git a/tests/ModelContextProtocol.Tests/Protocol/ListTasksResultTests.cs b/tests/ModelContextProtocol.Tests/Protocol/ListTasksResultTests.cs deleted file mode 100644 index 8d2fbd33b..000000000 --- a/tests/ModelContextProtocol.Tests/Protocol/ListTasksResultTests.cs +++ /dev/null @@ -1,46 +0,0 @@ -using ModelContextProtocol.Protocol; -using System.Text.Json; - -namespace ModelContextProtocol.Tests.Protocol; - -public static class ListTasksResultTests -{ - [Fact] - public static void ListTasksResult_SerializationRoundTrip() - { - // Arrange - var original = new ListTasksResult - { - Tasks = - [ - new McpTask - { - TaskId = "task-1", - Status = McpTaskStatus.Working, - CreatedAt = DateTimeOffset.UtcNow, - LastUpdatedAt = DateTimeOffset.UtcNow - }, - new McpTask - { - TaskId = "task-2", - Status = McpTaskStatus.Completed, - CreatedAt = DateTimeOffset.UtcNow, - LastUpdatedAt = DateTimeOffset.UtcNow - } - ], - NextCursor = "next-page-token" - }; - - // Act - string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); - var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); - - // Assert - Assert.NotNull(deserialized); - Assert.NotNull(deserialized.Tasks); - Assert.Equal(2, deserialized.Tasks.Count); - Assert.Equal(original.Tasks[0].TaskId, deserialized.Tasks[0].TaskId); - Assert.Equal(original.Tasks[1].TaskId, deserialized.Tasks[1].TaskId); - Assert.Equal(original.NextCursor, deserialized.NextCursor); - } -} diff --git a/tests/ModelContextProtocol.Tests/Protocol/McpTaskMetadataTests.cs b/tests/ModelContextProtocol.Tests/Protocol/McpTaskMetadataTests.cs deleted file mode 100644 index 82f33fbe7..000000000 --- a/tests/ModelContextProtocol.Tests/Protocol/McpTaskMetadataTests.cs +++ /dev/null @@ -1,53 +0,0 @@ -using ModelContextProtocol.Protocol; -using System.Text.Json; - -namespace ModelContextProtocol.Tests.Protocol; - -public static class McpTaskMetadataTests -{ - [Fact] - public static void McpTaskMetadata_SerializationRoundTrip_WithTimeToLive() - { - // Arrange - var original = new McpTaskMetadata - { - TimeToLive = TimeSpan.FromHours(2) - }; - - // Act - string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); - var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); - - // Assert - Assert.NotNull(deserialized); - Assert.Equal(original.TimeToLive, deserialized.TimeToLive); - } - - [Fact] - public static void McpTaskMetadata_SerializationRoundTrip_WithNullTimeToLive() - { - // Arrange - var original = new McpTaskMetadata(); - - // Act - string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); - var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); - - // Assert - Assert.NotNull(deserialized); - Assert.Null(deserialized.TimeToLive); - } - - [Fact] - public static void McpTaskMetadata_HasCorrectJsonPropertyNames() - { - var metadata = new McpTaskMetadata - { - TimeToLive = TimeSpan.FromMinutes(15) - }; - - string json = JsonSerializer.Serialize(metadata, McpJsonUtilities.DefaultOptions); - - Assert.Contains("\"ttl\":", json); - } -} diff --git a/tests/ModelContextProtocol.Tests/Protocol/McpTaskStatusNotificationParamsTests.cs b/tests/ModelContextProtocol.Tests/Protocol/McpTaskStatusNotificationParamsTests.cs deleted file mode 100644 index bf3cbbbf0..000000000 --- a/tests/ModelContextProtocol.Tests/Protocol/McpTaskStatusNotificationParamsTests.cs +++ /dev/null @@ -1,37 +0,0 @@ -using ModelContextProtocol.Protocol; -using System.Text.Json; - -namespace ModelContextProtocol.Tests.Protocol; - -public static class McpTaskStatusNotificationParamsTests -{ - [Fact] - public static void McpTaskStatusNotificationParams_SerializationRoundTrip() - { - // Arrange - var original = new McpTaskStatusNotificationParams - { - TaskId = "notification-task", - Status = McpTaskStatus.Completed, - StatusMessage = "Task completed successfully", - CreatedAt = new DateTimeOffset(2025, 12, 9, 10, 0, 0, TimeSpan.Zero), - LastUpdatedAt = new DateTimeOffset(2025, 12, 9, 10, 30, 0, TimeSpan.Zero), - TimeToLive = TimeSpan.FromHours(1), - PollInterval = TimeSpan.FromSeconds(2) - }; - - // Act - string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); - var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); - - // Assert - Assert.NotNull(deserialized); - Assert.Equal(original.TaskId, deserialized.TaskId); - Assert.Equal(original.Status, deserialized.Status); - Assert.Equal(original.StatusMessage, deserialized.StatusMessage); - Assert.Equal(original.CreatedAt, deserialized.CreatedAt); - Assert.Equal(original.LastUpdatedAt, deserialized.LastUpdatedAt); - Assert.Equal(original.TimeToLive, deserialized.TimeToLive); - Assert.Equal(original.PollInterval, deserialized.PollInterval); - } -} diff --git a/tests/ModelContextProtocol.Tests/Protocol/McpTaskTests.cs b/tests/ModelContextProtocol.Tests/Protocol/McpTaskTests.cs deleted file mode 100644 index 7919e408e..000000000 --- a/tests/ModelContextProtocol.Tests/Protocol/McpTaskTests.cs +++ /dev/null @@ -1,160 +0,0 @@ -using ModelContextProtocol.Protocol; -using System.Text.Json; - -namespace ModelContextProtocol.Tests.Protocol; - -public static class McpTaskTests -{ - [Fact] - public static void McpTask_SerializationRoundTrip_PreservesAllProperties() - { - // Arrange - var original = new McpTask - { - TaskId = "task-12345", - Status = McpTaskStatus.Working, - StatusMessage = "Processing request", - CreatedAt = new DateTimeOffset(2025, 12, 9, 10, 30, 0, TimeSpan.Zero), - LastUpdatedAt = new DateTimeOffset(2025, 12, 9, 10, 35, 0, TimeSpan.Zero), - TimeToLive = TimeSpan.FromHours(24), - PollInterval = TimeSpan.FromSeconds(5) - }; - - // Act - Serialize to JSON - string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); - - // Act - Deserialize back from JSON - var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); - - // Assert - Assert.NotNull(deserialized); - Assert.Equal(original.TaskId, deserialized.TaskId); - Assert.Equal(original.Status, deserialized.Status); - Assert.Equal(original.StatusMessage, deserialized.StatusMessage); - Assert.Equal(original.CreatedAt, deserialized.CreatedAt); - Assert.Equal(original.LastUpdatedAt, deserialized.LastUpdatedAt); - Assert.Equal(original.TimeToLive, deserialized.TimeToLive); - Assert.Equal(original.PollInterval, deserialized.PollInterval); - } - - [Fact] - public static void McpTask_SerializationRoundTrip_WithMinimalProperties() - { - // Arrange - var original = new McpTask - { - TaskId = "task-minimal", - Status = McpTaskStatus.Completed, - CreatedAt = DateTimeOffset.UtcNow, - LastUpdatedAt = DateTimeOffset.UtcNow - }; - - // Act - Serialize to JSON - string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); - - // Act - Deserialize back from JSON - var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); - - // Assert - Assert.NotNull(deserialized); - Assert.Equal(original.TaskId, deserialized.TaskId); - Assert.Equal(original.Status, deserialized.Status); - Assert.Null(deserialized.StatusMessage); - Assert.Equal(original.CreatedAt, deserialized.CreatedAt); - Assert.Equal(original.LastUpdatedAt, deserialized.LastUpdatedAt); - Assert.Null(deserialized.TimeToLive); - Assert.Null(deserialized.PollInterval); - } - - [Fact] - public static void McpTask_HasCorrectJsonPropertyNames() - { - var task = new McpTask - { - TaskId = "test-task", - Status = McpTaskStatus.Working, - StatusMessage = "Test message", - CreatedAt = DateTimeOffset.UtcNow, - LastUpdatedAt = DateTimeOffset.UtcNow, - TimeToLive = TimeSpan.FromMinutes(30), - PollInterval = TimeSpan.FromSeconds(1) - }; - - string json = JsonSerializer.Serialize(task, McpJsonUtilities.DefaultOptions); - - Assert.Contains("\"taskId\":", json); - Assert.Contains("\"status\":", json); - Assert.Contains("\"statusMessage\":", json); - Assert.Contains("\"createdAt\":", json); - Assert.Contains("\"lastUpdatedAt\":", json); - Assert.Contains("\"ttl\":", json); - Assert.Contains("\"pollInterval\":", json); - } - - [Fact] - public static void McpTask_TimeToLive_SerializesAsMilliseconds() - { - var task = new McpTask - { - TaskId = "test-ttl", - Status = McpTaskStatus.Working, - CreatedAt = DateTimeOffset.UtcNow, - LastUpdatedAt = DateTimeOffset.UtcNow, - TimeToLive = TimeSpan.FromSeconds(60) - }; - - string json = JsonSerializer.Serialize(task, McpJsonUtilities.DefaultOptions); - - Assert.Contains("\"ttl\":60000", json); - } - - [Theory] - [InlineData(McpTaskStatus.Working)] - [InlineData(McpTaskStatus.InputRequired)] - [InlineData(McpTaskStatus.Completed)] - [InlineData(McpTaskStatus.Failed)] - [InlineData(McpTaskStatus.Cancelled)] - public static void McpTaskStatus_SerializesCorrectly(McpTaskStatus status) - { - var task = new McpTask - { - TaskId = "status-test", - Status = status, - CreatedAt = DateTimeOffset.UtcNow, - LastUpdatedAt = DateTimeOffset.UtcNow - }; - - string json = JsonSerializer.Serialize(task, McpJsonUtilities.DefaultOptions); - var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); - - Assert.NotNull(deserialized); - Assert.Equal(status, deserialized.Status); - } - - [Fact] - public static void McpTaskStatus_HasCorrectJsonValues() - { - var statuses = new[] - { - (McpTaskStatus.Working, "working"), - (McpTaskStatus.InputRequired, "input_required"), - (McpTaskStatus.Completed, "completed"), - (McpTaskStatus.Failed, "failed"), - (McpTaskStatus.Cancelled, "cancelled") - }; - - foreach (var (status, expectedJson) in statuses) - { - var task = new McpTask - { - TaskId = "test", - Status = status, - CreatedAt = DateTimeOffset.UtcNow, - LastUpdatedAt = DateTimeOffset.UtcNow - }; - - string json = JsonSerializer.Serialize(task, McpJsonUtilities.DefaultOptions); - Assert.Contains($"\"status\":\"{expectedJson}\"", json); - } - } -} diff --git a/tests/ModelContextProtocol.Tests/Protocol/McpTasksCapabilityTests.cs b/tests/ModelContextProtocol.Tests/Protocol/McpTasksCapabilityTests.cs deleted file mode 100644 index 4e8caa740..000000000 --- a/tests/ModelContextProtocol.Tests/Protocol/McpTasksCapabilityTests.cs +++ /dev/null @@ -1,91 +0,0 @@ -using ModelContextProtocol.Protocol; -using System.Text.Json; - -namespace ModelContextProtocol.Tests.Protocol; - -public static class McpTasksCapabilityTests -{ - [Fact] - public static void McpTasksCapability_SerializationRoundTrip_WithAllProperties() - { - // Arrange - var original = new McpTasksCapability - { - List = new ListMcpTasksCapability(), - Cancel = new CancelMcpTasksCapability(), - Requests = new RequestMcpTasksCapability - { - Tools = new ToolsMcpTasksCapability - { - Call = new CallToolMcpTasksCapability() - }, - Sampling = new SamplingMcpTasksCapability - { - CreateMessage = new CreateMessageMcpTasksCapability() - }, - Elicitation = new ElicitationMcpTasksCapability - { - Create = new CreateElicitationMcpTasksCapability() - } - } - }; - - // Act - string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); - var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); - - // Assert - Assert.NotNull(deserialized); - Assert.NotNull(deserialized.List); - Assert.NotNull(deserialized.Cancel); - Assert.NotNull(deserialized.Requests); - Assert.NotNull(deserialized.Requests.Tools); - Assert.NotNull(deserialized.Requests.Tools.Call); - Assert.NotNull(deserialized.Requests.Sampling); - Assert.NotNull(deserialized.Requests.Sampling.CreateMessage); - Assert.NotNull(deserialized.Requests.Elicitation); - Assert.NotNull(deserialized.Requests.Elicitation.Create); - } - - [Fact] - public static void McpTasksCapability_SerializationRoundTrip_WithMinimalProperties() - { - // Arrange - var original = new McpTasksCapability(); - - // Act - string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); - var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); - - // Assert - Assert.NotNull(deserialized); - Assert.Null(deserialized.List); - Assert.Null(deserialized.Cancel); - Assert.Null(deserialized.Requests); - } - - [Fact] - public static void McpTasksCapability_HasCorrectJsonPropertyNames() - { - var capability = new McpTasksCapability - { - List = new ListMcpTasksCapability(), - Cancel = new CancelMcpTasksCapability(), - Requests = new RequestMcpTasksCapability - { - Tools = new ToolsMcpTasksCapability - { - Call = new CallToolMcpTasksCapability() - } - } - }; - - string json = JsonSerializer.Serialize(capability, McpJsonUtilities.DefaultOptions); - - Assert.Contains("\"list\":", json); - Assert.Contains("\"cancel\":", json); - Assert.Contains("\"requests\":", json); - Assert.Contains("\"tools\":", json); - Assert.Contains("\"call\":", json); - } -} diff --git a/tests/ModelContextProtocol.Tests/Protocol/MrtrSerializationTests.cs b/tests/ModelContextProtocol.Tests/Protocol/MrtrSerializationTests.cs new file mode 100644 index 000000000..e44f6527c --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Protocol/MrtrSerializationTests.cs @@ -0,0 +1,298 @@ +using ModelContextProtocol.Protocol; +using System.Text.Json; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.Tests.Protocol; + +public static class MrtrSerializationTests +{ + [Fact] + public static void IncompleteResult_SerializationRoundTrip_PreservesAllProperties() + { + var original = new InputRequiredResult + { + InputRequests = new Dictionary + { + ["input_1"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "What is your name?", + RequestedSchema = new() + }), + ["input_2"] = InputRequest.ForSampling(new CreateMessageRequestParams + { + Messages = [new SamplingMessage { Role = Role.User, Content = [new TextContentBlock { Text = "Hello" }] }], + MaxTokens = 100 + }) + }, + RequestState = "correlation-123", + }; + + string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); + var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); + + Assert.NotNull(deserialized); + Assert.Equal("input_required", deserialized.ResultType); + Assert.Equal("correlation-123", deserialized.RequestState); + Assert.NotNull(deserialized.InputRequests); + Assert.Equal(2, deserialized.InputRequests.Count); + Assert.True(deserialized.InputRequests.ContainsKey("input_1")); + Assert.True(deserialized.InputRequests.ContainsKey("input_2")); + } + + [Fact] + public static void IncompleteResult_HasResultTypeIncomplete() + { + var result = new InputRequiredResult(); + Assert.Equal("input_required", result.ResultType); + } + + [Fact] + public static void IncompleteResult_ResultType_AppearsInJson() + { + var result = new InputRequiredResult + { + RequestState = "abc", + }; + + string json = JsonSerializer.Serialize(result, McpJsonUtilities.DefaultOptions); + var node = JsonNode.Parse(json); + + Assert.NotNull(node); + Assert.Equal("input_required", (string?)node["resultType"]); + Assert.Equal("abc", (string?)node["requestState"]); + } + + [Fact] + public static void InputRequest_ForElicitation_SerializesCorrectly() + { + var inputRequest = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "Enter name", + RequestedSchema = new() + }); + + string json = JsonSerializer.Serialize(inputRequest, McpJsonUtilities.DefaultOptions); + var node = JsonNode.Parse(json); + + Assert.NotNull(node); + Assert.Equal("elicitation/create", (string?)node["method"]); + Assert.NotNull(node["params"]); + Assert.Equal("Enter name", (string?)node["params"]!["message"]); + } + + [Fact] + public static void InputRequest_ForSampling_SerializesCorrectly() + { + var inputRequest = InputRequest.ForSampling(new CreateMessageRequestParams + { + Messages = [new SamplingMessage { Role = Role.User, Content = [new TextContentBlock { Text = "Prompt" }] }], + MaxTokens = 50 + }); + + string json = JsonSerializer.Serialize(inputRequest, McpJsonUtilities.DefaultOptions); + var node = JsonNode.Parse(json); + + Assert.NotNull(node); + Assert.Equal("sampling/createMessage", (string?)node["method"]); + Assert.NotNull(node["params"]); + Assert.Equal(50, (int?)node["params"]!["maxTokens"]); + } + + [Fact] + public static void InputRequest_ForRootsList_SerializesCorrectly() + { + var inputRequest = InputRequest.ForRootsList(new ListRootsRequestParams()); + + string json = JsonSerializer.Serialize(inputRequest, McpJsonUtilities.DefaultOptions); + var node = JsonNode.Parse(json); + + Assert.NotNull(node); + Assert.Equal("roots/list", (string?)node["method"]); + } + + [Fact] + public static void InputRequest_Elicitation_RoundTrip() + { + var original = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "test message", + RequestedSchema = new() + }); + + string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); + var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); + + Assert.NotNull(deserialized); + Assert.Equal("elicitation/create", deserialized.Method); + Assert.NotNull(deserialized.ElicitationParams); + Assert.Equal("test message", deserialized.ElicitationParams.Message); + } + + [Fact] + public static void InputRequest_Sampling_RoundTrip() + { + var original = InputRequest.ForSampling(new CreateMessageRequestParams + { + Messages = [new SamplingMessage { Role = Role.User, Content = [new TextContentBlock { Text = "Hello" }] }], + MaxTokens = 200 + }); + + string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); + var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); + + Assert.NotNull(deserialized); + Assert.Equal("sampling/createMessage", deserialized.Method); + Assert.NotNull(deserialized.SamplingParams); + Assert.Equal(200, deserialized.SamplingParams.MaxTokens); + } + + [Fact] + public static void InputRequest_RootsList_RoundTrip() + { + var original = InputRequest.ForRootsList(new ListRootsRequestParams()); + + string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); + var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); + + Assert.NotNull(deserialized); + Assert.Equal("roots/list", deserialized.Method); + Assert.NotNull(deserialized.RootsParams); + } + + [Fact] + public static void InputResponse_FromSamplingResult_RoundTrip() + { + var samplingResult = new CreateMessageResult + { + Content = [new TextContentBlock { Text = "Response text" }], + Model = "test-model" + }; + + var inputResponse = InputResponse.FromSamplingResult(samplingResult); + + // Serialize → deserialize + string json = JsonSerializer.Serialize(inputResponse, McpJsonUtilities.DefaultOptions); + var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); + + Assert.NotNull(deserialized); + var sampling = deserialized.Deserialize(InputResponse.CreateMessageResultJsonTypeInfo); + Assert.NotNull(sampling); + Assert.Equal("test-model", sampling.Model); + } + + [Fact] + public static void InputResponse_FromElicitResult_RoundTrip() + { + var elicitResult = new ElicitResult + { + Action = "confirm", + Content = new Dictionary + { + ["key"] = JsonDocument.Parse("\"value\"").RootElement.Clone() + } + }; + + var inputResponse = InputResponse.FromElicitResult(elicitResult); + + string json = JsonSerializer.Serialize(inputResponse, McpJsonUtilities.DefaultOptions); + var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); + + Assert.NotNull(deserialized); + var elicit = deserialized.Deserialize(InputResponse.ElicitResultJsonTypeInfo); + Assert.NotNull(elicit); + Assert.Equal("confirm", elicit.Action); + } + + [Fact] + public static void InputResponse_FromRootsResult_RoundTrip() + { + var rootsResult = new ListRootsResult + { + Roots = [new Root { Uri = "file:///test", Name = "Test" }] + }; + + var inputResponse = InputResponse.FromRootsResult(rootsResult); + + string json = JsonSerializer.Serialize(inputResponse, McpJsonUtilities.DefaultOptions); + var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); + + Assert.NotNull(deserialized); + var roots = deserialized.Deserialize(InputResponse.ListRootsResultJsonTypeInfo); + Assert.NotNull(roots); + Assert.Single(roots.Roots); + Assert.Equal("file:///test", roots.Roots[0].Uri); + } + + [Fact] + public static void InputRequestDictionary_SerializationRoundTrip() + { + IDictionary requests = new Dictionary + { + ["a"] = InputRequest.ForElicitation(new ElicitRequestParams { Message = "q1", RequestedSchema = new() }), + ["b"] = InputRequest.ForSampling(new CreateMessageRequestParams + { + Messages = [new SamplingMessage { Role = Role.User, Content = [new TextContentBlock { Text = "q2" }] }], + MaxTokens = 50 + }), + }; + + string json = JsonSerializer.Serialize(requests, McpJsonUtilities.DefaultOptions); + var deserialized = JsonSerializer.Deserialize>(json, McpJsonUtilities.DefaultOptions); + + Assert.NotNull(deserialized); + Assert.Equal(2, deserialized.Count); + Assert.Equal("elicitation/create", deserialized["a"].Method); + Assert.Equal("sampling/createMessage", deserialized["b"].Method); + } + + [Fact] + public static void InputResponseDictionary_SerializationRoundTrip() + { + IDictionary responses = new Dictionary + { + ["a"] = InputResponse.FromElicitResult(new ElicitResult { Action = "confirm" }), + ["b"] = InputResponse.FromSamplingResult(new CreateMessageResult + { + Content = [new TextContentBlock { Text = "AI" }], + Model = "m1" + }), + }; + + string json = JsonSerializer.Serialize(responses, McpJsonUtilities.DefaultOptions); + var deserialized = JsonSerializer.Deserialize>(json, McpJsonUtilities.DefaultOptions); + + Assert.NotNull(deserialized); + Assert.Equal(2, deserialized.Count); + } + + [Fact] + public static void Result_ResultType_DefaultsToNull() + { + var result = new CallToolResult + { + Content = [new TextContentBlock { Text = "test" }] + }; + + string json = JsonSerializer.Serialize(result, McpJsonUtilities.DefaultOptions); + var node = JsonNode.Parse(json); + + // result_type should not appear for normal results + Assert.Null(node?["resultType"]); + } + + [Fact] + public static void RequestParams_InputResponses_NotSerializedByDefault() + { + var callParams = new CallToolRequestParams + { + Name = "test-tool", + }; + + string json = JsonSerializer.Serialize(callParams, McpJsonUtilities.DefaultOptions); + var node = JsonNode.Parse(json); + + // inputResponses and requestState should not appear when null + Assert.Null(node?["inputResponses"]); + Assert.Null(node?["requestState"]); + } +} diff --git a/tests/ModelContextProtocol.Tests/Protocol/RequestIdTests.cs b/tests/ModelContextProtocol.Tests/Protocol/RequestIdTests.cs index e426c7469..ba9120cb3 100644 --- a/tests/ModelContextProtocol.Tests/Protocol/RequestIdTests.cs +++ b/tests/ModelContextProtocol.Tests/Protocol/RequestIdTests.cs @@ -35,4 +35,32 @@ public void Int64Ctor_Roundtrips() Assert.Equal(id, JsonSerializer.Deserialize(JsonSerializer.Serialize(id, McpJsonUtilities.DefaultOptions), McpJsonUtilities.DefaultOptions)); } + + [Fact] + public void Null_DeserializesAsDefault() + { + // Per JSON-RPC 2.0 §5.1, error responses produced before the request id can be determined + // MUST carry id=null. Deserialization needs to tolerate that shape so callers can handle + // such error envelopes (instead of throwing on the bare RequestId conversion). + var id = JsonSerializer.Deserialize("null", McpJsonUtilities.DefaultOptions); + Assert.Equal(default(RequestId), id); + Assert.Null(id.Id); + } + + [Fact] + public void Null_SerializesAsJsonNull() + { + // The default RequestId (Id == null) is the id-less-error-response shape. It MUST serialize as + // JSON null — not "" — so the wire form is spec-conformant and round-trips losslessly. + Assert.Equal("null", JsonSerializer.Serialize(default(RequestId), McpJsonUtilities.DefaultOptions)); + } + + [Fact] + public void Null_Roundtrips() + { + var json = JsonSerializer.Serialize(default(RequestId), McpJsonUtilities.DefaultOptions); + var id = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); + Assert.Equal(default(RequestId), id); + Assert.Null(id.Id); + } } diff --git a/tests/ModelContextProtocol.Tests/Protocol/RequestMcpTasksCapabilityTests.cs b/tests/ModelContextProtocol.Tests/Protocol/RequestMcpTasksCapabilityTests.cs deleted file mode 100644 index 8bfcb3be4..000000000 --- a/tests/ModelContextProtocol.Tests/Protocol/RequestMcpTasksCapabilityTests.cs +++ /dev/null @@ -1,108 +0,0 @@ -using ModelContextProtocol.Protocol; -using System.Text.Json; - -namespace ModelContextProtocol.Tests.Protocol; - -public static class RequestMcpTasksCapabilityTests -{ - [Fact] - public static void RequestMcpTasksCapability_SerializationRoundTrip_ToolsOnly() - { - // Arrange - var original = new RequestMcpTasksCapability - { - Tools = new ToolsMcpTasksCapability - { - Call = new CallToolMcpTasksCapability() - } - }; - - // Act - string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); - var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); - - // Assert - Assert.NotNull(deserialized); - Assert.NotNull(deserialized.Tools); - Assert.NotNull(deserialized.Tools.Call); - Assert.Null(deserialized.Sampling); - Assert.Null(deserialized.Elicitation); - } - - [Fact] - public static void RequestMcpTasksCapability_SerializationRoundTrip_SamplingOnly() - { - // Arrange - var original = new RequestMcpTasksCapability - { - Sampling = new SamplingMcpTasksCapability - { - CreateMessage = new CreateMessageMcpTasksCapability() - } - }; - - // Act - string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); - var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); - - // Assert - Assert.NotNull(deserialized); - Assert.Null(deserialized.Tools); - Assert.NotNull(deserialized.Sampling); - Assert.NotNull(deserialized.Sampling.CreateMessage); - Assert.Null(deserialized.Elicitation); - } - - [Fact] - public static void RequestMcpTasksCapability_SerializationRoundTrip_ElicitationOnly() - { - // Arrange - var original = new RequestMcpTasksCapability - { - Elicitation = new ElicitationMcpTasksCapability - { - Create = new CreateElicitationMcpTasksCapability() - } - }; - - // Act - string json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); - var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); - - // Assert - Assert.NotNull(deserialized); - Assert.Null(deserialized.Tools); - Assert.Null(deserialized.Sampling); - Assert.NotNull(deserialized.Elicitation); - Assert.NotNull(deserialized.Elicitation.Create); - } - - [Fact] - public static void RequestMcpTasksCapability_HasCorrectJsonPropertyNames() - { - var capability = new RequestMcpTasksCapability - { - Tools = new ToolsMcpTasksCapability - { - Call = new CallToolMcpTasksCapability() - }, - Sampling = new SamplingMcpTasksCapability - { - CreateMessage = new CreateMessageMcpTasksCapability() - }, - Elicitation = new ElicitationMcpTasksCapability - { - Create = new CreateElicitationMcpTasksCapability() - } - }; - - string json = JsonSerializer.Serialize(capability, McpJsonUtilities.DefaultOptions); - - Assert.Contains("\"tools\":", json); - Assert.Contains("\"sampling\":", json); - Assert.Contains("\"elicitation\":", json); - Assert.Contains("\"call\":", json); - Assert.Contains("\"createMessage\":", json); - Assert.Contains("\"create\":", json); - } -} diff --git a/tests/ModelContextProtocol.Tests/Protocol/ServerCapabilitiesTests.cs b/tests/ModelContextProtocol.Tests/Protocol/ServerCapabilitiesTests.cs index a6f8265f1..7b95e911b 100644 --- a/tests/ModelContextProtocol.Tests/Protocol/ServerCapabilitiesTests.cs +++ b/tests/ModelContextProtocol.Tests/Protocol/ServerCapabilitiesTests.cs @@ -15,7 +15,6 @@ public static void ServerCapabilities_SerializationRoundTrip_PreservesAllPropert Resources = new ResourcesCapability { Subscribe = true, ListChanged = true }, Tools = new ToolsCapability { ListChanged = false }, Completions = new CompletionsCapability(), - Tasks = new McpTasksCapability(), Extensions = new Dictionary { ["io.modelcontextprotocol/apps"] = new object() @@ -35,7 +34,6 @@ public static void ServerCapabilities_SerializationRoundTrip_PreservesAllPropert Assert.NotNull(deserialized.Tools); Assert.False(deserialized.Tools.ListChanged); Assert.NotNull(deserialized.Completions); - Assert.NotNull(deserialized.Tasks); Assert.NotNull(deserialized.Extensions); Assert.True(deserialized.Extensions.ContainsKey("io.modelcontextprotocol/apps")); } @@ -55,7 +53,6 @@ public static void ServerCapabilities_SerializationRoundTrip_WithMinimalProperti Assert.Null(deserialized.Resources); Assert.Null(deserialized.Tools); Assert.Null(deserialized.Completions); - Assert.Null(deserialized.Tasks); Assert.Null(deserialized.Extensions); } diff --git a/tests/ModelContextProtocol.Tests/Protocol/SubscriptionsListenProtocolTests.cs b/tests/ModelContextProtocol.Tests/Protocol/SubscriptionsListenProtocolTests.cs new file mode 100644 index 000000000..65c26e035 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Protocol/SubscriptionsListenProtocolTests.cs @@ -0,0 +1,63 @@ +using ModelContextProtocol.Protocol; +using System.Text.Json; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.Tests.Protocol; + +/// +/// Serialization tests for the subscriptions/listen types introduced by the 2026-07-28 protocol revision (SEP-2575). +/// +public static class SubscriptionsListenProtocolTests +{ + [Fact] + public static void SubscriptionsListenRequestParams_SerializationRoundTrip_PreservesAllProperties() + { + var original = new SubscriptionsListenRequestParams + { + Notifications = new SubscriptionsListenNotifications + { + ToolsListChanged = true, + PromptsListChanged = true, + ResourcesListChanged = true, + ResourceSubscriptions = new List { "file:///foo.txt", "file:///bar.txt" }, + }, + Meta = new JsonObject + { + [MetaKeys.ProtocolVersion] = "2026-07-28", + [MetaKeys.LogLevel] = "info", + }, + }; + + var json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); + var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); + + Assert.NotNull(deserialized); + Assert.True(deserialized.Notifications.ToolsListChanged); + Assert.True(deserialized.Notifications.PromptsListChanged); + Assert.True(deserialized.Notifications.ResourcesListChanged); + Assert.NotNull(deserialized.Notifications.ResourceSubscriptions); + Assert.Equal(["file:///foo.txt", "file:///bar.txt"], deserialized.Notifications.ResourceSubscriptions); + Assert.Equal("2026-07-28", (string)deserialized.Meta![MetaKeys.ProtocolVersion]!); + } + + [Fact] + public static void SubscriptionsAcknowledgedNotificationParams_SerializationRoundTrip_PreservesNotifications() + { + var original = new SubscriptionsAcknowledgedNotificationParams + { + Notifications = new SubscriptionsListenNotifications + { + ToolsListChanged = true, + }, + }; + + var json = JsonSerializer.Serialize(original, McpJsonUtilities.DefaultOptions); + var deserialized = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); + + Assert.NotNull(deserialized); + Assert.True(deserialized.Notifications.ToolsListChanged); + Assert.Null(deserialized.Notifications.PromptsListChanged); + Assert.Null(deserialized.Notifications.ResourcesListChanged); + Assert.Null(deserialized.Notifications.ResourceSubscriptions); + } +} diff --git a/tests/ModelContextProtocol.Tests/Protocol/TaskSerializationTests.cs b/tests/ModelContextProtocol.Tests/Protocol/TaskSerializationTests.cs new file mode 100644 index 000000000..f2e4472ce --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Protocol/TaskSerializationTests.cs @@ -0,0 +1,530 @@ +using ModelContextProtocol.Extensions.Tasks; +using ModelContextProtocol.Protocol; +using System.Text.Json; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.Tests.Protocol; + +/// +/// Serialization and deserialization tests for SEP-2663 task protocol types. +/// +public static class TaskSerializationTests +{ + #region CreateTaskResult + + [Fact] + public static void CreateTaskResult_SerializationRoundTrip_PreservesAllProperties() + { + var original = new CreateTaskResult + { + TaskId = "task-123", + Status = McpTaskStatus.Working, + StatusMessage = "Processing...", + CreatedAt = new DateTimeOffset(2025, 6, 1, 12, 0, 0, TimeSpan.Zero), + LastUpdatedAt = new DateTimeOffset(2025, 6, 1, 12, 5, 0, TimeSpan.Zero), + TimeToLive = TimeSpan.FromHours(1), + PollIntervalMs = 5000, + ResultType = "task", + Meta = new JsonObject { ["key"] = "value" } + }; + + string json = JsonSerializer.Serialize(original, McpTasksJsonContext.Default.Options); + var deserialized = JsonSerializer.Deserialize(json, McpTasksJsonContext.Default.Options); + + Assert.NotNull(deserialized); + Assert.Equal("task-123", deserialized.TaskId); + Assert.Equal(McpTaskStatus.Working, deserialized.Status); + Assert.Equal("Processing...", deserialized.StatusMessage); + Assert.Equal(original.CreatedAt, deserialized.CreatedAt); + Assert.Equal(original.LastUpdatedAt, deserialized.LastUpdatedAt); + Assert.Equal(TimeSpan.FromHours(1), deserialized.TimeToLive); + Assert.Equal(5000, deserialized.PollIntervalMs); + Assert.Equal("task", deserialized.ResultType); + Assert.NotNull(deserialized.Meta); + Assert.Equal("value", (string)deserialized.Meta["key"]!); + } + + [Fact] + public static void CreateTaskResult_UsesCorrectWireFieldNames() + { + var result = new CreateTaskResult + { + TaskId = "t1", + Status = McpTaskStatus.Working, + CreatedAt = DateTimeOffset.UtcNow, + LastUpdatedAt = DateTimeOffset.UtcNow, + TimeToLive = TimeSpan.FromMinutes(1), + PollIntervalMs = 1000, + ResultType = "task", + }; + + string json = JsonSerializer.Serialize(result, McpTasksJsonContext.Default.Options); + + // Must use camelCase wire names + Assert.Contains("\"ttlMs\":", json); + Assert.Contains("\"pollIntervalMs\":", json); + Assert.Contains("\"taskId\":", json); + Assert.Contains("\"resultType\":\"task\"", json); + + // Must NOT contain legacy field names + Assert.DoesNotContain("\"ttl\":", json); + Assert.DoesNotContain("\"pollInterval\":", json); + } + + [Fact] + public static void CreateTaskResult_ResultType_SerializesAsTask() + { + var result = new CreateTaskResult + { + TaskId = "t1", + Status = McpTaskStatus.Working, + CreatedAt = DateTimeOffset.UtcNow, + LastUpdatedAt = DateTimeOffset.UtcNow, + ResultType = "task", + }; + + string json = JsonSerializer.Serialize(result, McpTasksJsonContext.Default.Options); + var node = JsonNode.Parse(json)!; + + Assert.Equal("task", (string)node["resultType"]!); + } + + #endregion + + [Theory] + [InlineData(typeof(UpdateTaskResult))] + [InlineData(typeof(CancelTaskResult))] + public static void TaskAcknowledgement_SerializesExplicitCompleteResultType(Type resultType) + { + var result = (Result)Activator.CreateInstance(resultType)!; + + var json = JsonSerializer.SerializeToNode(result, resultType, McpTasksJsonContext.Default.Options)!; + + Assert.Equal("complete", (string)json["resultType"]!); + } + + #region GetTaskResult Subtypes + + [Fact] + public static void GetTaskResult_Working_RoundTrip() + { + var original = new WorkingTaskResult + { + TaskId = "w1", + CreatedAt = new DateTimeOffset(2025, 1, 1, 0, 0, 0, TimeSpan.Zero), + LastUpdatedAt = new DateTimeOffset(2025, 1, 1, 0, 1, 0, TimeSpan.Zero), + StatusMessage = "In progress", + PollIntervalMs = 2000, + }; + + string json = JsonSerializer.Serialize(original, McpTasksJsonContext.Default.Options); + var deserialized = JsonSerializer.Deserialize(json, McpTasksJsonContext.Default.Options); + + var working = Assert.IsType(deserialized); + Assert.Equal("w1", working.TaskId); + Assert.Equal(McpTaskStatus.Working, working.Status); + Assert.Equal("In progress", working.StatusMessage); + Assert.Equal(2000, working.PollIntervalMs); + } + + [Fact] + public static void GetTaskResult_Completed_RoundTrip_IncludesResult() + { + var resultPayload = JsonElement.Parse("""{"content":[{"type":"text","text":"done"}]}"""); + var original = new CompletedTaskResult + { + TaskId = "c1", + CreatedAt = DateTimeOffset.UtcNow, + LastUpdatedAt = DateTimeOffset.UtcNow, + Result = resultPayload, + }; + + string json = JsonSerializer.Serialize(original, McpTasksJsonContext.Default.Options); + var deserialized = JsonSerializer.Deserialize(json, McpTasksJsonContext.Default.Options); + + var completed = Assert.IsType(deserialized); + Assert.Equal("c1", completed.TaskId); + Assert.Equal(McpTaskStatus.Completed, completed.Status); + Assert.Equal(JsonValueKind.Object, completed.Result.ValueKind); + } + + [Fact] + public static void GetTaskResult_Failed_RoundTrip_IncludesError() + { + var errorPayload = JsonElement.Parse("""{"code":-32000,"message":"internal error"}"""); + var original = new FailedTaskResult + { + TaskId = "f1", + CreatedAt = DateTimeOffset.UtcNow, + LastUpdatedAt = DateTimeOffset.UtcNow, + Error = errorPayload, + }; + + string json = JsonSerializer.Serialize(original, McpTasksJsonContext.Default.Options); + var deserialized = JsonSerializer.Deserialize(json, McpTasksJsonContext.Default.Options); + + var failed = Assert.IsType(deserialized); + Assert.Equal("f1", failed.TaskId); + Assert.Equal(McpTaskStatus.Failed, failed.Status); + Assert.Equal(-32000, failed.Error.GetProperty("code").GetInt32()); + } + + [Fact] + public static void GetTaskResult_Cancelled_RoundTrip() + { + var original = new CancelledTaskResult + { + TaskId = "x1", + CreatedAt = DateTimeOffset.UtcNow, + LastUpdatedAt = DateTimeOffset.UtcNow, + StatusMessage = "User cancelled", + }; + + string json = JsonSerializer.Serialize(original, McpTasksJsonContext.Default.Options); + var deserialized = JsonSerializer.Deserialize(json, McpTasksJsonContext.Default.Options); + + var cancelled = Assert.IsType(deserialized); + Assert.Equal("x1", cancelled.TaskId); + Assert.Equal(McpTaskStatus.Cancelled, cancelled.Status); + Assert.Equal("User cancelled", cancelled.StatusMessage); + } + + [Fact] + public static void GetTaskResult_InputRequired_RoundTrip_IncludesInputRequests() + { + var inputRequests = new Dictionary + { + ["req-1"] = new InputRequest + { + Method = "elicitation/create", + Params = JsonElement.Parse("""{"message":"Confirm?"}"""), + } + }; + var original = new InputRequiredTaskResult + { + TaskId = "i1", + CreatedAt = DateTimeOffset.UtcNow, + LastUpdatedAt = DateTimeOffset.UtcNow, + InputRequests = inputRequests, + }; + + string json = JsonSerializer.Serialize(original, McpTasksJsonContext.Default.Options); + var deserialized = JsonSerializer.Deserialize(json, McpTasksJsonContext.Default.Options); + + var inputRequired = Assert.IsType(deserialized); + Assert.Equal("i1", inputRequired.TaskId); + Assert.Equal(McpTaskStatus.InputRequired, inputRequired.Status); + Assert.NotNull(inputRequired.InputRequests); + Assert.Single(inputRequired.InputRequests); + Assert.True(inputRequired.InputRequests.ContainsKey("req-1")); + } + + [Fact] + public static void GetTaskResult_Converter_DispatchesToCorrectSubtypeByStatus() + { + var statuses = new (string status, Type expectedType)[] + { + ("working", typeof(WorkingTaskResult)), + ("completed", typeof(CompletedTaskResult)), + ("failed", typeof(FailedTaskResult)), + ("cancelled", typeof(CancelledTaskResult)), + ("input_required", typeof(InputRequiredTaskResult)), + }; + + foreach (var (status, expectedType) in statuses) + { + var json = status switch + { + "completed" => """{"taskId":"t","status":"completed","createdAt":"2025-01-01T00:00:00Z","lastUpdatedAt":"2025-01-01T00:00:00Z","result":{}}""", + "failed" => """{"taskId":"t","status":"failed","createdAt":"2025-01-01T00:00:00Z","lastUpdatedAt":"2025-01-01T00:00:00Z","error":{}}""", + "input_required" => """{"taskId":"t","status":"input_required","createdAt":"2025-01-01T00:00:00Z","lastUpdatedAt":"2025-01-01T00:00:00Z","inputRequests":{}}""", + _ => $$$"""{"taskId":"t","status":"{{{status}}}","createdAt":"2025-01-01T00:00:00Z","lastUpdatedAt":"2025-01-01T00:00:00Z"}""", + }; + + var result = JsonSerializer.Deserialize(json, McpTasksJsonContext.Default.Options); + Assert.NotNull(result); + Assert.IsType(expectedType, result); + } + } + + [Fact] + public static void GetTaskResult_MissingTaskId_ThrowsJsonException() + { + var json = """{"status":"working","createdAt":"2025-01-01T00:00:00Z","lastUpdatedAt":"2025-01-01T00:00:00Z"}"""; + Assert.Throws(() => JsonSerializer.Deserialize(json, McpTasksJsonContext.Default.Options)); + } + + [Fact] + public static void GetTaskResult_MissingStatus_ThrowsJsonException() + { + var json = """{"taskId":"t","createdAt":"2025-01-01T00:00:00Z","lastUpdatedAt":"2025-01-01T00:00:00Z"}"""; + Assert.Throws(() => JsonSerializer.Deserialize(json, McpTasksJsonContext.Default.Options)); + } + + [Fact] + public static void GetTaskResult_UnknownStatus_ThrowsJsonException() + { + var json = """{"taskId":"t","status":"exploded","createdAt":"2025-01-01T00:00:00Z","lastUpdatedAt":"2025-01-01T00:00:00Z"}"""; + Assert.Throws(() => JsonSerializer.Deserialize(json, McpTasksJsonContext.Default.Options)); + } + + [Fact] + public static void GetTaskResult_CompletedMissingResult_ThrowsJsonException() + { + var json = """{"taskId":"t","status":"completed","createdAt":"2025-01-01T00:00:00Z","lastUpdatedAt":"2025-01-01T00:00:00Z"}"""; + Assert.Throws(() => JsonSerializer.Deserialize(json, McpTasksJsonContext.Default.Options)); + } + + [Fact] + public static void GetTaskResult_FailedMissingError_ThrowsJsonException() + { + var json = """{"taskId":"t","status":"failed","createdAt":"2025-01-01T00:00:00Z","lastUpdatedAt":"2025-01-01T00:00:00Z"}"""; + Assert.Throws(() => JsonSerializer.Deserialize(json, McpTasksJsonContext.Default.Options)); + } + + [Fact] + public static void GetTaskResult_InputRequiredMissingInputRequests_ThrowsJsonException() + { + var json = """{"taskId":"t","status":"input_required","createdAt":"2025-01-01T00:00:00Z","lastUpdatedAt":"2025-01-01T00:00:00Z"}"""; + Assert.Throws(() => JsonSerializer.Deserialize(json, McpTasksJsonContext.Default.Options)); + } + + [Theory] + [InlineData(typeof(WorkingTaskResult))] + [InlineData(typeof(CompletedTaskResult))] + [InlineData(typeof(FailedTaskResult))] + [InlineData(typeof(CancelledTaskResult))] + [InlineData(typeof(InputRequiredTaskResult))] + public static void GetTaskResult_WireResultType_IsComplete_WhenSet(Type subType) + { + // SEP-2663: standard task responses (tasks/get, tasks/update, tasks/cancel) use resultType="complete". + var created = new DateTimeOffset(2025, 1, 1, 0, 0, 0, TimeSpan.Zero); + GetTaskResult value = subType switch + { + Type t when t == typeof(WorkingTaskResult) => new WorkingTaskResult { TaskId = "t", CreatedAt = created, LastUpdatedAt = created, ResultType = "complete" }, + Type t when t == typeof(CompletedTaskResult) => new CompletedTaskResult { TaskId = "t", CreatedAt = created, LastUpdatedAt = created, Result = JsonElement.Parse("""{"ok":true}"""), ResultType = "complete" }, + Type t when t == typeof(FailedTaskResult) => new FailedTaskResult { TaskId = "t", CreatedAt = created, LastUpdatedAt = created, Error = JsonElement.Parse("""{"code":-32603,"message":"boom"}"""), ResultType = "complete" }, + Type t when t == typeof(CancelledTaskResult) => new CancelledTaskResult { TaskId = "t", CreatedAt = created, LastUpdatedAt = created, ResultType = "complete" }, + Type t when t == typeof(InputRequiredTaskResult) => new InputRequiredTaskResult + { + TaskId = "t", + CreatedAt = created, + LastUpdatedAt = created, + ResultType = "complete", + InputRequests = new Dictionary + { + ["k"] = new InputRequest + { + Method = "test/method", + Params = JsonSerializer.SerializeToElement("ask", McpTasksJsonContext.Default.Options), + }, + }, + }, + _ => throw new InvalidOperationException() + }; + + string json = JsonSerializer.Serialize(value, McpTasksJsonContext.Default.Options); + var node = JsonNode.Parse(json)!; + + Assert.Equal("complete", (string?)node["resultType"]); + } + + #endregion + + #region McpTaskStatus Enum + + [Theory] + [InlineData(McpTaskStatus.Working, "working")] + [InlineData(McpTaskStatus.InputRequired, "input_required")] + [InlineData(McpTaskStatus.Completed, "completed")] + [InlineData(McpTaskStatus.Cancelled, "cancelled")] + [InlineData(McpTaskStatus.Failed, "failed")] + public static void McpTaskStatus_SerializesAsSnakeCase(McpTaskStatus status, string expectedWireValue) + { + string json = JsonSerializer.Serialize(status, McpTasksJsonContext.Default.Options); + Assert.Equal($"\"{expectedWireValue}\"", json); + + var deserialized = JsonSerializer.Deserialize(json, McpTasksJsonContext.Default.Options); + Assert.Equal(status, deserialized); + } + + #endregion + + #region TaskStatusNotificationParams + + [Fact] + public static void TaskStatusNotificationParams_Working_RoundTrip() + { + var original = new WorkingTaskNotificationParams + { + TaskId = "n1", + CreatedAt = DateTimeOffset.UtcNow, + LastUpdatedAt = DateTimeOffset.UtcNow, + StatusMessage = "Working on it", + }; + + string json = JsonSerializer.Serialize(original, McpTasksJsonContext.Default.Options); + var deserialized = JsonSerializer.Deserialize(json, McpTasksJsonContext.Default.Options); + + var working = Assert.IsType(deserialized); + Assert.Equal("n1", working.TaskId); + Assert.Equal("Working on it", working.StatusMessage); + } + + [Fact] + public static void TaskStatusNotificationParams_Completed_RoundTrip() + { + var resultPayload = JsonElement.Parse("""{"text":"done"}"""); + var original = new CompletedTaskNotificationParams + { + TaskId = "n2", + CreatedAt = DateTimeOffset.UtcNow, + LastUpdatedAt = DateTimeOffset.UtcNow, + Result = resultPayload, + }; + + string json = JsonSerializer.Serialize(original, McpTasksJsonContext.Default.Options); + var deserialized = JsonSerializer.Deserialize(json, McpTasksJsonContext.Default.Options); + + var completed = Assert.IsType(deserialized); + Assert.Equal("n2", completed.TaskId); + Assert.Equal("done", completed.Result.GetProperty("text").GetString()); + } + + [Fact] + public static void TaskStatusNotificationParams_Failed_RoundTrip() + { + var errorPayload = JsonElement.Parse("""{"code":-1,"message":"boom"}"""); + var original = new FailedTaskNotificationParams + { + TaskId = "n3", + CreatedAt = DateTimeOffset.UtcNow, + LastUpdatedAt = DateTimeOffset.UtcNow, + Error = errorPayload, + }; + + string json = JsonSerializer.Serialize(original, McpTasksJsonContext.Default.Options); + var deserialized = JsonSerializer.Deserialize(json, McpTasksJsonContext.Default.Options); + + var failed = Assert.IsType(deserialized); + Assert.Equal("n3", failed.TaskId); + Assert.Equal("boom", failed.Error.GetProperty("message").GetString()); + } + + [Fact] + public static void TaskStatusNotificationParams_Cancelled_RoundTrip() + { + var original = new CancelledTaskNotificationParams + { + TaskId = "n4", + CreatedAt = DateTimeOffset.UtcNow, + LastUpdatedAt = DateTimeOffset.UtcNow, + }; + + string json = JsonSerializer.Serialize(original, McpTasksJsonContext.Default.Options); + var deserialized = JsonSerializer.Deserialize(json, McpTasksJsonContext.Default.Options); + + Assert.IsType(deserialized); + } + + [Fact] + public static void TaskStatusNotificationParams_InputRequired_RoundTrip() + { + var inputRequests = new Dictionary + { + ["r1"] = new InputRequest { Method = "sampling/createMessage" } + }; + var original = new InputRequiredTaskNotificationParams + { + TaskId = "n5", + CreatedAt = DateTimeOffset.UtcNow, + LastUpdatedAt = DateTimeOffset.UtcNow, + InputRequests = inputRequests, + }; + + string json = JsonSerializer.Serialize(original, McpTasksJsonContext.Default.Options); + var deserialized = JsonSerializer.Deserialize(json, McpTasksJsonContext.Default.Options); + + var inputRequired = Assert.IsType(deserialized); + Assert.NotNull(inputRequired.InputRequests); + Assert.Single(inputRequired.InputRequests); + } + + #endregion + + #region ResultOrAlternate + + [Fact] + public static void ResultOrAlternate_ImplicitConversion_FromResult() + { + CallToolResult callResult = new() { Content = [new TextContentBlock { Text = "hi" }] }; + + ResultOrCreatedTask augmented = callResult; + + Assert.False(augmented.IsTask); + Assert.Same(callResult, augmented.Result); + Assert.Null(augmented.TaskCreated); + } + + [Fact] + public static void ResultOrAlternate_ImplicitConversion_FromCreateTaskResult() + { + CreateTaskResult taskCreated = new() + { + TaskId = "t1", + Status = McpTaskStatus.Working, + CreatedAt = DateTimeOffset.UtcNow, + LastUpdatedAt = DateTimeOffset.UtcNow, + }; + + ResultOrCreatedTask augmented = taskCreated; + + Assert.True(augmented.IsTask); + Assert.Same(taskCreated, augmented.TaskCreated); + Assert.Null(augmented.Result); + } + + [Fact] + public static void ResultOrAlternate_IsTask_FalseForResult_TrueForTask() + { + var result = new ResultOrCreatedTask(new CallToolResult()); + var task = new ResultOrCreatedTask(new CreateTaskResult + { + TaskId = "t", + Status = McpTaskStatus.Working, + CreatedAt = DateTimeOffset.UtcNow, + LastUpdatedAt = DateTimeOffset.UtcNow, + }); + + Assert.False(result.IsTask); + Assert.True(task.IsTask); + } + + #endregion + + #region UpdateTaskResult / CancelTaskResult Wire Format + + [Fact] + public static void UpdateTaskResult_WireResultType_IsComplete_WhenSet() + { + // SEP-2663: tasks/update responses use resultType="complete". + var result = new UpdateTaskResult { ResultType = "complete" }; + string json = JsonSerializer.Serialize(result, McpTasksJsonContext.Default.Options); + var node = JsonNode.Parse(json)!; + + Assert.Equal("complete", (string?)node["resultType"]); + } + + [Fact] + public static void CancelTaskResult_WireResultType_IsComplete_WhenSet() + { + // SEP-2663: tasks/cancel responses use resultType="complete". + var result = new CancelTaskResult { ResultType = "complete" }; + string json = JsonSerializer.Serialize(result, McpTasksJsonContext.Default.Options); + var node = JsonNode.Parse(json)!; + + Assert.Equal("complete", (string?)node["resultType"]); + } + + #endregion +} diff --git a/tests/ModelContextProtocol.Tests/Protocol/ToolTests.cs b/tests/ModelContextProtocol.Tests/Protocol/ToolTests.cs index 5b2160571..150f6d307 100644 --- a/tests/ModelContextProtocol.Tests/Protocol/ToolTests.cs +++ b/tests/ModelContextProtocol.Tests/Protocol/ToolTests.cs @@ -105,6 +105,14 @@ public static void ToolInputSchema_HasValidDefaultSchema() Assert.Equal("object", typeElement.GetString()); } + [Fact] + public static void ToolInputSchema_DeserializationRejectsMissingInputSchema() + { + const string json = """{"name":"test"}"""; + + Assert.Throws(() => JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions)); + } + [Theory] [InlineData("null")] [InlineData("false")] @@ -139,4 +147,51 @@ public static void ToolInputSchema_AcceptsValidSchemaDocuments(string validSchem Assert.True(JsonElement.DeepEquals(document.RootElement, tool.InputSchema)); } + + [Theory] + [InlineData("null")] + [InlineData("3.5e3")] + [InlineData("[]")] + [InlineData("\"a-string\"")] + public static void ToolOutputSchema_RejectsInvalidJsonSchemaDocuments(string invalidSchema) + { + // Per SEP-2106 / JSON Schema 2020-12 §4.3, a schema document is either a JSON object + // or a boolean (true/false). Other JSON values — null literals, numbers, strings, + // arrays — are not valid schema documents and are rejected. + using var document = JsonDocument.Parse(invalidSchema); + var tool = new Tool { Name = "test" }; + + Assert.Throws(() => tool.OutputSchema = document.RootElement); + } + + [Theory] + [InlineData("""{"type":"object"}""")] + [InlineData("""{"type":"object","properties":{"name":{"type":"string"}},"required":["name"]}""")] + [InlineData("""{"type":"array","items":{"type":"integer"}}""")] + [InlineData("""{"type":"string"}""")] + [InlineData("""{"type":"number"}""")] + [InlineData("""{"type":"integer","minimum":0}""")] + [InlineData("""{"type":"boolean"}""")] + [InlineData("""{"type":["object","null"],"properties":{"name":{"type":"string"}}}""")] + [InlineData("""{}""")] + [InlineData("""{"oneOf":[{"type":"string"},{"type":"integer"}]}""")] + [InlineData("true")] + [InlineData("false")] + public static void ToolOutputSchema_AcceptsAnyValidJsonSchemaDocument(string validSchema) + { + // Per SEP-2106, OutputSchema accepts any valid JSON Schema 2020-12 document — JSON + // objects (with arrays, primitives, compositions, nullable types) plus the boolean + // schemas `true` (matches any value) and `false` (matches nothing). The `true` form + // also appears organically as the auto-derived schema for an unconstrained `object` + // return type. + using var document = JsonDocument.Parse(validSchema); + Tool tool = new() + { + Name = "test", + OutputSchema = document.RootElement, + }; + + Assert.NotNull(tool.OutputSchema); + Assert.True(JsonElement.DeepEquals(document.RootElement, tool.OutputSchema.Value)); + } } diff --git a/tests/ModelContextProtocol.Tests/Protocol/UrlElicitationTests.cs b/tests/ModelContextProtocol.Tests/Protocol/UrlElicitationTests.cs index bf4c67d21..8d97eb52d 100644 --- a/tests/ModelContextProtocol.Tests/Protocol/UrlElicitationTests.cs +++ b/tests/ModelContextProtocol.Tests/Protocol/UrlElicitationTests.cs @@ -190,6 +190,16 @@ await request.Server.ElicitAsync(new() }); } + // These tests assert on the root server's ClientCapabilities (see AssertServerElicitationCapability), + // which is only session-scoped under the initialize-handshake revisions. Pin to the latest such revision + // so the capabilities negotiated during initialize are observable on the root McpServer. Request-scoped + // capability behavior under the 2026-07-28 revision is covered by McpClientMetaTests. + private Task CreateLegacyClientForServer(McpClientOptions clientOptions) + { + clientOptions.ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion; + return CreateMcpClientForServer(clientOptions); + } + [Fact] public async Task Can_Elicit_OutOfBand_With_Url() { @@ -198,7 +208,7 @@ public async Task Can_Elicit_OutOfBand_With_Url() string? capturedMessage = null; var completionNotification = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - await using McpClient client = await CreateMcpClientForServer(new McpClientOptions + await using McpClient client = await CreateLegacyClientForServer(new McpClientOptions { Capabilities = new ClientCapabilities { @@ -283,7 +293,7 @@ public async Task Can_Elicit_OutOfBand_With_Url() [Fact] public async Task UrlElicitation_User_Can_Decline() { - await using McpClient client = await CreateMcpClientForServer(new McpClientOptions + await using McpClient client = await CreateLegacyClientForServer(new McpClientOptions { Capabilities = new ClientCapabilities { @@ -322,7 +332,7 @@ public async Task UrlElicitation_User_Can_Decline() [Fact] public async Task UrlElicitation_User_Can_Cancel() { - await using McpClient client = await CreateMcpClientForServer(new McpClientOptions + await using McpClient client = await CreateLegacyClientForServer(new McpClientOptions { Capabilities = new ClientCapabilities { @@ -360,7 +370,7 @@ public async Task UrlElicitation_User_Can_Cancel() [Fact] public async Task UrlElicitation_Defaults_To_Unsupported_When_Handler_Provided() { - await using McpClient client = await CreateMcpClientForServer(new McpClientOptions + await using McpClient client = await CreateLegacyClientForServer(new McpClientOptions { Handlers = new McpClientHandlers() { @@ -385,7 +395,7 @@ public async Task UrlElicitation_Defaults_To_Unsupported_When_Handler_Provided() [Fact] public async Task FormElicitation_Defaults_To_Supported_When_Handler_Provided() { - await using McpClient client = await CreateMcpClientForServer(new McpClientOptions + await using McpClient client = await CreateLegacyClientForServer(new McpClientOptions { Handlers = new McpClientHandlers() { @@ -406,7 +416,7 @@ public async Task FormElicitation_Defaults_To_Supported_When_Handler_Provided() [Fact] public async Task UrlElicitation_BlankCapability_Allows_Only_Form() { - await using McpClient client = await CreateMcpClientForServer(new McpClientOptions + await using McpClient client = await CreateLegacyClientForServer(new McpClientOptions { Capabilities = new ClientCapabilities { @@ -435,7 +445,7 @@ public async Task UrlElicitation_BlankCapability_Allows_Only_Form() [Fact] public async Task FormElicitation_UrlOnlyCapability_NotSupported() { - await using McpClient client = await CreateMcpClientForServer(new McpClientOptions + await using McpClient client = await CreateLegacyClientForServer(new McpClientOptions { Capabilities = new ClientCapabilities { @@ -474,7 +484,7 @@ public async Task UrlElicitation_Requires_ElicitationId_For_Url_Mode() { var elicitationHandlerCalled = false; - await using McpClient client = await CreateMcpClientForServer(new McpClientOptions + await using McpClient client = await CreateLegacyClientForServer(new McpClientOptions { Capabilities = new ClientCapabilities { @@ -504,7 +514,7 @@ public async Task UrlElicitation_Requires_ElicitationId_For_Url_Mode() [Fact] public async Task UrlElicitationRequired_Exception_Propagates_To_Client() { - await using McpClient client = await CreateMcpClientForServer(new McpClientOptions + await using McpClient client = await CreateLegacyClientForServer(new McpClientOptions { Capabilities = new ClientCapabilities { @@ -532,7 +542,7 @@ public async Task FormElicitation_Requires_RequestedSchema() { var elicitationHandlerCalled = false; - await using McpClient client = await CreateMcpClientForServer(new McpClientOptions + await using McpClient client = await CreateLegacyClientForServer(new McpClientOptions { Capabilities = new ClientCapabilities { diff --git a/tests/ModelContextProtocol.Tests/Server/AutomaticInputRequiredStatusTests.cs b/tests/ModelContextProtocol.Tests/Server/AutomaticInputRequiredStatusTests.cs deleted file mode 100644 index 1f5c51c6c..000000000 --- a/tests/ModelContextProtocol.Tests/Server/AutomaticInputRequiredStatusTests.cs +++ /dev/null @@ -1,478 +0,0 @@ -using Microsoft.Extensions.DependencyInjection; -using Microsoft.Extensions.Logging; -using ModelContextProtocol.Client; -using ModelContextProtocol.Protocol; -using ModelContextProtocol.Server; -using ModelContextProtocol.Tests.Utils; -using System.IO.Pipelines; - -namespace ModelContextProtocol.Tests.Server; - -/// -/// Tests for automatic InputRequired status tracking when server-to-client -/// requests (SampleAsync, ElicitAsync) are made during task-augmented tool execution. -/// -public class AutomaticInputRequiredStatusTests : LoggedTest -{ - public AutomaticInputRequiredStatusTests(ITestOutputHelper testOutputHelper) - : base(testOutputHelper) - { - } - -#pragma warning disable MCPEXP001 // Tasks feature is experimental - - [Fact] - public async Task TaskStatus_TransitionsToInputRequired_DuringSampleAsync() - { - // Arrange - var taskStore = new InMemoryMcpTaskStore(); - var statusesDuringSampling = new List(); - var samplingRequestReceived = new TaskCompletionSource(); - var continueSampling = new TaskCompletionSource(); - - await using var fixture = new InputRequiredTestFixture( - LoggerFactory, - configureServer: (services, builder) => - { - services.AddSingleton(taskStore); - services.Configure(options => - { - options.TaskStore = taskStore; - options.SendTaskStatusNotifications = true; // Enable notifications - }); - - // Tool that calls SampleAsync during execution - builder.WithTools([McpServerTool.Create( - async (string prompt, McpServer server, CancellationToken ct) => - { - // Call SampleAsync - this should trigger InputRequired status - var result = await server.SampleAsync(new CreateMessageRequestParams - { - Messages = [new SamplingMessage - { - Role = Role.User, - Content = [new TextContentBlock { Text = prompt }] - }], - MaxTokens = 100 - }, ct); - - var textContent = result.Content.OfType().FirstOrDefault(); - return textContent?.Text ?? "No response"; - }, - new McpServerToolCreateOptions - { - Name = "sampling-tool", - Description = "A tool that uses sampling" - })]); - }, - configureClient: clientOptions => - { - clientOptions.Handlers = new McpClientHandlers - { - SamplingHandler = async (request, progress, ct) => - { - // Signal that we received the sampling request - samplingRequestReceived.TrySetResult(true); - - // Wait for permission to continue (so we can check status) - await continueSampling.Task.WaitAsync(ct); - - return new CreateMessageResult - { - Content = [new TextContentBlock { Text = "Sampled response" }], - Model = "test-model" - }; - } - }; - }); - - // Act - Call the tool as a task - var mcpTask = await fixture.Client.CallToolAsTaskAsync( - "sampling-tool", - arguments: new Dictionary { ["prompt"] = "Hello" }, - taskMetadata: new McpTaskMetadata(), - progress: null, - cancellationToken: TestContext.Current.CancellationToken); - - // Wait for the sampling request to be received by the client - await samplingRequestReceived.Task.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); - - // Check the task status while sampling is in progress - var statusDuringSampling = await taskStore.GetTaskAsync( - mcpTask.TaskId, - cancellationToken: TestContext.Current.CancellationToken); - - if (statusDuringSampling is not null) - { - statusesDuringSampling.Add(statusDuringSampling.Status); - } - - // Allow sampling to complete - continueSampling.TrySetResult(true); - - // Wait for task to complete - McpTask? finalStatus = null; - int maxAttempts = 50; - do - { - await Task.Delay(100, TestContext.Current.CancellationToken); - finalStatus = await taskStore.GetTaskAsync(mcpTask.TaskId, cancellationToken: TestContext.Current.CancellationToken); - maxAttempts--; - } - while (finalStatus?.Status is not McpTaskStatus.Completed && maxAttempts > 0); - - // Assert - Status should have been InputRequired during sampling - Assert.Contains(McpTaskStatus.InputRequired, statusesDuringSampling); - - // Final status should be Completed - Assert.NotNull(finalStatus); - Assert.Equal(McpTaskStatus.Completed, finalStatus.Status); - } - - [Fact] - public async Task TaskStatus_TransitionsToInputRequired_DuringElicitAsync() - { - // Arrange - var taskStore = new InMemoryMcpTaskStore(); - var statusesDuringElicitation = new List(); - var elicitationRequestReceived = new TaskCompletionSource(); - var continueElicitation = new TaskCompletionSource(); - - await using var fixture = new InputRequiredTestFixture( - LoggerFactory, - configureServer: (services, builder) => - { - services.AddSingleton(taskStore); - services.Configure(options => - { - options.TaskStore = taskStore; - options.SendTaskStatusNotifications = true; - }); - - // Tool that calls ElicitAsync during execution - builder.WithTools([McpServerTool.Create( - async (string message, McpServer server, CancellationToken ct) => - { - // Call ElicitAsync - this should trigger InputRequired status - var result = await server.ElicitAsync(new ElicitRequestParams - { - Message = message, - RequestedSchema = new() - }, ct); - - return result.Action == "confirm" ? "Confirmed" : "Declined"; - }, - new McpServerToolCreateOptions - { - Name = "elicitation-tool", - Description = "A tool that uses elicitation" - })]); - }, - configureClient: clientOptions => - { - clientOptions.Handlers = new McpClientHandlers - { - ElicitationHandler = async (request, ct) => - { - // Signal that we received the elicitation request - elicitationRequestReceived.TrySetResult(true); - - // Wait for permission to continue - await continueElicitation.Task.WaitAsync(ct); - - return new ElicitResult { Action = "confirm" }; - } - }; - }); - - // Act - Call the tool as a task - var mcpTask = await fixture.Client.CallToolAsTaskAsync( - "elicitation-tool", - arguments: new Dictionary { ["message"] = "Please confirm" }, - taskMetadata: new McpTaskMetadata(), - progress: null, - cancellationToken: TestContext.Current.CancellationToken); - - // Wait for the elicitation request to be received - await elicitationRequestReceived.Task.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); - - // Check the task status while elicitation is in progress - var statusDuringElicitation = await taskStore.GetTaskAsync( - mcpTask.TaskId, - cancellationToken: TestContext.Current.CancellationToken); - - if (statusDuringElicitation is not null) - { - statusesDuringElicitation.Add(statusDuringElicitation.Status); - } - - // Allow elicitation to complete - continueElicitation.TrySetResult(true); - - // Wait for task to complete - McpTask? finalStatus = null; - int maxAttempts = 50; - do - { - await Task.Delay(100, TestContext.Current.CancellationToken); - finalStatus = await taskStore.GetTaskAsync(mcpTask.TaskId, cancellationToken: TestContext.Current.CancellationToken); - maxAttempts--; - } - while (finalStatus?.Status is not McpTaskStatus.Completed && maxAttempts > 0); - - // Assert - Status should have been InputRequired during elicitation - Assert.Contains(McpTaskStatus.InputRequired, statusesDuringElicitation); - - // Final status should be Completed - Assert.NotNull(finalStatus); - Assert.Equal(McpTaskStatus.Completed, finalStatus.Status); - } - - [Fact] - public async Task TaskStatus_ReturnsToWorking_AfterSamplingCompletes() - { - // Arrange - var taskStore = new InMemoryMcpTaskStore(); - var samplingCompleted = new TaskCompletionSource(); - var checkStatusAfterSampling = new TaskCompletionSource(); - - await using var fixture = new InputRequiredTestFixture( - LoggerFactory, - configureServer: (services, builder) => - { - services.AddSingleton(taskStore); - services.Configure(options => - { - options.TaskStore = taskStore; - }); - - // Tool that calls SampleAsync and then waits - builder.WithTools([McpServerTool.Create( - async (string prompt, McpServer server, CancellationToken ct) => - { - // Call SampleAsync - var result = await server.SampleAsync(new CreateMessageRequestParams - { - Messages = [new SamplingMessage - { - Role = Role.User, - Content = [new TextContentBlock { Text = prompt }] - }], - MaxTokens = 100 - }, ct); - - // Signal that sampling completed - samplingCompleted.TrySetResult(true); - - // Wait so test can check status - await checkStatusAfterSampling.Task.WaitAsync(ct); - - var textContent = result.Content.OfType().FirstOrDefault(); - return textContent?.Text ?? "No response"; - }, - new McpServerToolCreateOptions - { - Name = "sampling-tool", - Description = "A tool that uses sampling" - })]); - }, - configureClient: clientOptions => - { - clientOptions.Handlers = new McpClientHandlers - { - SamplingHandler = (request, progress, ct) => - { - // Return immediately to let sampling complete - return new ValueTask(new CreateMessageResult - { - Content = [new TextContentBlock { Text = "Response" }], - Model = "test-model" - }); - } - }; - }); - - // Act - Call the tool as a task - var mcpTask = await fixture.Client.CallToolAsTaskAsync( - "sampling-tool", - arguments: new Dictionary { ["prompt"] = "Hello" }, - taskMetadata: new McpTaskMetadata(), - progress: null, - cancellationToken: TestContext.Current.CancellationToken); - - // Wait for sampling to complete inside the tool - await samplingCompleted.Task.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); - - // Small delay to ensure status update is processed - await Task.Delay(50, TestContext.Current.CancellationToken); - - // Check status after sampling completed (should be back to Working) - var taskAfterSampling = await taskStore.GetTaskAsync(mcpTask.TaskId, cancellationToken: TestContext.Current.CancellationToken); - - // Allow tool to complete - checkStatusAfterSampling.TrySetResult(true); - - // Assert - Status should be Working after sampling completes (before tool completes) - Assert.NotNull(taskAfterSampling); - Assert.Equal(McpTaskStatus.Working, taskAfterSampling.Status); - } - - [Fact] - public async Task TaskStatus_DoesNotChangeToInputRequired_ForNonTaskExecution() - { - // Arrange - When a tool is NOT executed as a task, SampleAsync should not change any task status - var taskStore = new InMemoryMcpTaskStore(); - var samplingCompleted = new TaskCompletionSource(); - - await using var fixture = new InputRequiredTestFixture( - LoggerFactory, - configureServer: (services, builder) => - { - services.AddSingleton(taskStore); - services.Configure(options => - { - options.TaskStore = taskStore; - }); - - // Tool that calls SampleAsync - note it doesn't have TaskSupport.Required so can be called directly - builder.WithTools([McpServerTool.Create( - async (string prompt, McpServer server, CancellationToken ct) => - { - var result = await server.SampleAsync(new CreateMessageRequestParams - { - Messages = [new SamplingMessage - { - Role = Role.User, - Content = [new TextContentBlock { Text = prompt }] - }], - MaxTokens = 100 - }, ct); - - samplingCompleted.TrySetResult(true); - var textContent = result.Content.OfType().FirstOrDefault(); - return textContent?.Text ?? "No response"; - }, - new McpServerToolCreateOptions - { - Name = "sampling-tool", - Description = "A tool that uses sampling", - Execution = new ToolExecution { TaskSupport = ToolTaskSupport.Optional } - })]); - }, - configureClient: clientOptions => - { - clientOptions.Handlers = new McpClientHandlers - { - SamplingHandler = (request, progress, ct) => - { - return new ValueTask(new CreateMessageResult - { - Content = [new TextContentBlock { Text = "Response" }], - Model = "test-model" - }); - } - }; - }); - - // Act - Call the tool DIRECTLY (not as a task) - var result = await fixture.Client.CallToolAsync( - "sampling-tool", - arguments: new Dictionary { ["prompt"] = "Hello" }, - cancellationToken: TestContext.Current.CancellationToken); - - await samplingCompleted.Task.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); - - // Assert - No task should exist (tool was not called as a task) - var tasks = await taskStore.ListTasksAsync(cancellationToken: TestContext.Current.CancellationToken); - Assert.Empty(tasks.Tasks); - - // And the result should still work - Assert.NotNull(result); - } - -#pragma warning restore MCPEXP001 - - /// - /// Test fixture that supports both server and client configuration for InputRequired status tests. - /// - private sealed class InputRequiredTestFixture : IAsyncDisposable - { - private readonly Pipe _clientToServerPipe = new(); - private readonly Pipe _serverToClientPipe = new(); - private readonly IServiceProvider _serviceProvider; - private readonly McpServer _server; - private readonly Task _serverTask; - private readonly CancellationTokenSource _cts; - - public McpClient Client { get; } - public McpServer Server => _server; - - public InputRequiredTestFixture( - ILoggerFactory loggerFactory, - Action? configureServer = null, - Action? configureClient = null) - { - _cts = new CancellationTokenSource(); - - // Configure server - var services = new ServiceCollection(); - services.AddLogging(); - services.AddSingleton(loggerFactory); - - var builder = services - .AddMcpServer() - .WithStreamServerTransport( - _clientToServerPipe.Reader.AsStream(), - _serverToClientPipe.Writer.AsStream()); - - configureServer?.Invoke(services, builder); - - _serviceProvider = services.BuildServiceProvider(validateScopes: true); - _server = _serviceProvider.GetRequiredService(); - _serverTask = _server.RunAsync(_cts.Token); - - // Configure client - var clientOptions = new McpClientOptions(); - configureClient?.Invoke(clientOptions); - - // Create client synchronously (test code) - Client = McpClient.CreateAsync( - new StreamClientTransport( - serverInput: _clientToServerPipe.Writer.AsStream(), - _serverToClientPipe.Reader.AsStream(), - loggerFactory), - clientOptions: clientOptions, - loggerFactory: loggerFactory, - cancellationToken: TestContext.Current.CancellationToken).GetAwaiter().GetResult(); - } - - public async ValueTask DisposeAsync() - { - await Client.DisposeAsync(); - await _cts.CancelAsync(); - - _clientToServerPipe.Writer.Complete(); - _serverToClientPipe.Writer.Complete(); - - try - { - await _serverTask; - } - catch (OperationCanceledException) - { - // Expected - } - - if (_serviceProvider is IAsyncDisposable asyncDisposable) - { - await asyncDisposable.DisposeAsync(); - } - else if (_serviceProvider is IDisposable disposable) - { - disposable.Dispose(); - } - - _cts.Dispose(); - } - } -} diff --git a/tests/ModelContextProtocol.Tests/Server/CallToolFilterMixingTests.cs b/tests/ModelContextProtocol.Tests/Server/CallToolFilterMixingTests.cs new file mode 100644 index 000000000..e891c8ce7 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/CallToolFilterMixingTests.cs @@ -0,0 +1,85 @@ +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using ModelContextProtocol.Tests.Utils; + +namespace ModelContextProtocol.Tests.Server; + +/// +/// Verifies composition for the non-alternate +/// and alternate pipelines. +/// +public class CallToolFilterMixingTests(ITestOutputHelper testOutputHelper) : LoggedTest(testOutputHelper) +{ +#pragma warning disable MCPEXP002 // exercises the experimental CallToolWithAlternateFilters seam + private static McpRequestFilter PassThroughCallToolFilter => + next => next; + + private static McpRequestInvocationFilter> PassThroughAlternateFilter => + static (context, next, cancellationToken) => next(context, cancellationToken); + + [Fact] + public async Task MixingCallToolFilters_WithAlternateFilters_Succeeds() + { + await using var transport = new StreamServerTransport(Stream.Null, Stream.Null); + var options = new McpServerOptions { Capabilities = new() { Tools = new() } }; + options.Filters.Request.CallToolWithAlternateFilters.Add(PassThroughAlternateFilter); + options.Filters.Request.CallToolFilters.Add(PassThroughCallToolFilter); + + await using var server = McpServer.Create(transport, options, LoggerFactory); + + Assert.NotNull(server); + } + + [Fact] + public async Task AlternateFilters_AddedAfterOrdinaryFilters_Succeeds() + { + await using var transport = new StreamServerTransport(Stream.Null, Stream.Null); + var options = new McpServerOptions { Capabilities = new() { Tools = new() } }; + options.Filters.Request.CallToolFilters.Add(PassThroughCallToolFilter); + options.Filters.Request.CallToolWithAlternateFilters.Add(PassThroughAlternateFilter); + + await using var server = McpServer.Create(transport, options, LoggerFactory); + + Assert.NotNull(server); + } + + [Fact] + public async Task CallToolFilters_WithExplicitAlternateHandler_ThrowsActionableError() + { + await using var transport = new StreamServerTransport(Stream.Null, Stream.Null); + var options = new McpServerOptions { Capabilities = new() { Tools = new() } }; + options.Handlers.CallToolWithAlternateHandler = static (_, _) => + new(new ResultOrAlternate(new CallToolResult())); + options.Filters.Request.CallToolFilters.Add(PassThroughCallToolFilter); + + var ex = Assert.Throws( + () => McpServer.Create(transport, options, LoggerFactory)); + + Assert.Contains(nameof(McpRequestFilters.CallToolFilters), ex.Message); + Assert.Contains(nameof(McpServerHandlers.CallToolWithAlternateHandler), ex.Message); + Assert.Contains("replaces the ordinary tool-call pipeline", ex.Message); + } + + [Fact] + public async Task CallToolFiltersAlone_Succeeds() + { + await using var transport = new StreamServerTransport(Stream.Null, Stream.Null); + var options = new McpServerOptions { Capabilities = new() { Tools = new() } }; + options.Filters.Request.CallToolFilters.Add(PassThroughCallToolFilter); + + await using var server = McpServer.Create(transport, options, LoggerFactory); + Assert.NotNull(server); + } + + [Fact] + public async Task AlternateFiltersAlone_Succeeds() + { + await using var transport = new StreamServerTransport(Stream.Null, Stream.Null); + var options = new McpServerOptions { Capabilities = new() { Tools = new() } }; + options.Filters.Request.CallToolWithAlternateFilters.Add(PassThroughAlternateFilter); + + await using var server = McpServer.Create(transport, options, LoggerFactory); + Assert.NotNull(server); + } +#pragma warning restore MCPEXP002 +} diff --git a/tests/ModelContextProtocol.Tests/Server/CustomRequestHandlerCollisionTests.cs b/tests/ModelContextProtocol.Tests/Server/CustomRequestHandlerCollisionTests.cs new file mode 100644 index 000000000..56e8fd1e6 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/CustomRequestHandlerCollisionTests.cs @@ -0,0 +1,102 @@ +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using ModelContextProtocol.Tests.Utils; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.Tests.Server; + +/// +/// Verifies that custom request handlers registered through +/// cannot silently replace a built-in method +/// or another custom handler. +/// +public class CustomRequestHandlerCollisionTests(ITestOutputHelper testOutputHelper) : LoggedTest(testOutputHelper) +{ +#pragma warning disable MCPEXP002 + private static McpServerRequestHandler CreateHandler(string method) => new() + { + Method = method, + Handler = (request, cancellationToken) => new ValueTask((JsonNode?)null), + }; + + [Fact] + public async Task CustomHandler_CollidingWithBuiltInMethod_Throws() + { + await using var transport = new StreamServerTransport(Stream.Null, Stream.Null); + var options = new McpServerOptions + { + Capabilities = new() { Tools = new() }, + RequestHandlers = [CreateHandler("tools/call")], + }; + + var ex = Assert.Throws( + () => McpServer.Create(transport, options, LoggerFactory)); + + Assert.Contains("tools/call", ex.Message); + } + + [Fact] + public async Task CustomHandler_CollidingWithInitialize_Throws() + { + await using var transport = new StreamServerTransport(Stream.Null, Stream.Null); + var options = new McpServerOptions + { + RequestHandlers = [CreateHandler("initialize")], + }; + + Assert.Throws( + () => McpServer.Create(transport, options, LoggerFactory)); + } + + [Fact] + public async Task CustomHandler_DuplicateCustomMethod_Throws() + { + await using var transport = new StreamServerTransport(Stream.Null, Stream.Null); + var options = new McpServerOptions + { + RequestHandlers = [CreateHandler("custom/method"), CreateHandler("custom/method")], + }; + + var ex = Assert.Throws( + () => McpServer.Create(transport, options, LoggerFactory)); + + Assert.Contains("custom/method", ex.Message); + } + + [Fact] + public async Task CustomHandler_UniqueMethod_Succeeds() + { + await using var transport = new StreamServerTransport(Stream.Null, Stream.Null); + var options = new McpServerOptions + { + RequestHandlers = [CreateHandler("custom/method")], + }; + + await using var server = McpServer.Create(transport, options, LoggerFactory); + Assert.NotNull(server); + } + + [Fact] + public async Task CustomHandler_EmptyRoutingNameParameter_Throws() + { + await using var transport = new StreamServerTransport(Stream.Null, Stream.Null); + var options = new McpServerOptions + { + RequestHandlers = + [ + new McpServerRequestHandler + { + Method = "custom/method", + RoutingNameParameter = " ", + Handler = (request, cancellationToken) => new ValueTask((JsonNode?)null), + }, + ], + }; + + var ex = Assert.Throws( + () => McpServer.Create(transport, options, LoggerFactory)); + + Assert.Contains(nameof(McpServerRequestHandler.RoutingNameParameter), ex.Message); + } +#pragma warning restore MCPEXP002 +} diff --git a/tests/ModelContextProtocol.Tests/Server/DistributedCacheEventStreamStoreTests.cs b/tests/ModelContextProtocol.Tests/Server/DistributedCacheEventStreamStoreTests.cs index 0983e6ad9..f306064f8 100644 --- a/tests/ModelContextProtocol.Tests/Server/DistributedCacheEventStreamStoreTests.cs +++ b/tests/ModelContextProtocol.Tests/Server/DistributedCacheEventStreamStoreTests.cs @@ -904,10 +904,16 @@ public async Task ReadEventsAsync_InStreamingMode_YieldsNewlyWrittenEvents() using var cts = CancellationTokenSource.CreateLinkedTokenSource(CancellationToken); cts.CancelAfter(TimeSpan.FromSeconds(10)); var events = new List>(); + + // Use a TCS as a sync point: set when the reader has confirmed receipt of the first event. + // This guarantees the streaming enumerator is definitely active before we write events 2 and 3. + var readerStarted = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + var readTask = Task.Run(async () => { await foreach (var evt in reader.ReadEventsAsync(cts.Token)) { + readerStarted.TrySetResult(true); events.Add(evt); if (events.Count >= 3) { @@ -916,8 +922,13 @@ public async Task ReadEventsAsync_InStreamingMode_YieldsNewlyWrittenEvents() } }, CancellationToken); - // Write 3 new events - the reader should pick them up since it's in streaming mode + // Write the first event and wait for the reader to confirm it has been received. + // This establishes a synchronization point: once readerStarted is signalled, we know + // the streaming loop is running and will reliably observe any subsequently written events. var event1 = await writer.WriteEventAsync(new SseItem(null), CancellationToken); + await readerStarted.Task.WaitAsync(cts.Token); + + // Write the remaining 2 events now that the reader is confirmed active var event2 = await writer.WriteEventAsync(new SseItem(null), CancellationToken); var event3 = await writer.WriteEventAsync(new SseItem(null), CancellationToken); diff --git a/tests/ModelContextProtocol.Tests/Server/InMemoryMcpTaskStoreTests.cs b/tests/ModelContextProtocol.Tests/Server/InMemoryMcpTaskStoreTests.cs index 7d2fc5596..236740f61 100644 --- a/tests/ModelContextProtocol.Tests/Server/InMemoryMcpTaskStoreTests.cs +++ b/tests/ModelContextProtocol.Tests/Server/InMemoryMcpTaskStoreTests.cs @@ -1,1231 +1,549 @@ -using Microsoft.Extensions.Time.Testing; +using ModelContextProtocol.Extensions.Tasks; using ModelContextProtocol.Protocol; using ModelContextProtocol.Server; -using ModelContextProtocol.Tests.Utils; using System.Text.Json; -using TestInMemoryMcpTaskStore = ModelContextProtocol.Tests.Internal.InMemoryMcpTaskStore; + +#pragma warning disable MCPEXP001 namespace ModelContextProtocol.Tests.Server; -public class InMemoryMcpTaskStoreTests : LoggedTest +/// +/// Unit tests for . +/// +public class InMemoryMcpTaskStoreTests { - public InMemoryMcpTaskStoreTests(ITestOutputHelper testOutputHelper) - : base(testOutputHelper) - { - } + private CancellationToken CT => TestContext.Current.CancellationToken; + + private static InputRequest MakeRequest(string payload) => + new() { Method = "test/method", Params = JsonSerializer.SerializeToElement(payload, McpJsonUtilities.DefaultOptions) }; + + private static InputResponse MakeResponse(string payload) => + new() { RawValue = JsonSerializer.SerializeToElement(payload, McpJsonUtilities.DefaultOptions) }; [Fact] - public async Task CreateTaskAsync_CreatesTaskWithUniqueId() + public async Task CreateTaskAsync_ReturnsWorkingTaskWithUniqueId() { - // Arrange - using var store = new InMemoryMcpTaskStore(); - var metadata = new McpTaskMetadata(); - var requestId = new RequestId("req-1"); - var request = new JsonRpcRequest { Method = "tools/call" }; + var store = new InMemoryMcpTaskStore(); - // Act - var task = await store.CreateTaskAsync(metadata, requestId, request, "session-1", TestContext.Current.CancellationToken); + var result = await store.CreateTaskAsync(CT); - // Assert - Assert.NotNull(task); - Assert.NotEmpty(task.TaskId); - Assert.Equal(McpTaskStatus.Working, task.Status); - Assert.NotEqual(default, task.CreatedAt); - Assert.NotEqual(default, task.LastUpdatedAt); + Assert.NotNull(result); + Assert.NotEmpty(result.TaskId); + Assert.Equal(McpTaskStatus.Working, result.Status); + Assert.NotEqual(default, result.CreatedAt); + Assert.NotEqual(default, result.LastUpdatedAt); } [Fact] - public async Task CreateTaskAsync_GeneratesUniqueTaskIds() + public async Task CreateTaskAsync_GeneratesUniqueIds() { - // Arrange - using var store = new InMemoryMcpTaskStore(); - var metadata = new McpTaskMetadata(); + var store = new InMemoryMcpTaskStore(); - // Act - var task1 = await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - var task2 = await store.CreateTaskAsync(metadata, new RequestId("req-2"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); + var task1 = await store.CreateTaskAsync(CT); + var task2 = await store.CreateTaskAsync(CT); - // Assert Assert.NotEqual(task1.TaskId, task2.TaskId); } [Fact] - public async Task CreateTaskAsync_AppliesTtlFromMetadata() + public async Task CreateTaskAsync_UsesDefaultPollInterval() { - // Arrange - using var store = new InMemoryMcpTaskStore(); - var metadata = new McpTaskMetadata - { - TimeToLive = TimeSpan.FromSeconds(5) - }; + var store = new InMemoryMcpTaskStore { DefaultPollIntervalMs = 500 }; - // Act - var task = await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); + var result = await store.CreateTaskAsync(CT); - // Assert - Assert.Equal(TimeSpan.FromSeconds(5), task.TimeToLive); + Assert.Equal(500, result.PollIntervalMs); } [Fact] - public async Task CreateTaskAsync_CapsMaxTtl() + public async Task CreateTaskAsync_UsesDefaultTimeToLive() { - // Arrange - var maxTtl = TimeSpan.FromMinutes(5); - using var store = new InMemoryMcpTaskStore(maxTtl: maxTtl); - var metadata = new McpTaskMetadata - { - TimeToLive = TimeSpan.FromHours(1) // Request 1 hour - }; + var store = new InMemoryMcpTaskStore { DefaultTimeToLive = TimeSpan.FromSeconds(30) }; - // Act - var task = await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); + var result = await store.CreateTaskAsync(CT); - // Assert - Assert.Equal(maxTtl, task.TimeToLive); + Assert.Equal(TimeSpan.FromSeconds(30), result.TimeToLive); } [Fact] - public async Task GetTaskAsync_ReturnsTaskById() + public async Task GetTaskAsync_ReturnsWorkingTask() { - // Arrange - using var store = new InMemoryMcpTaskStore(); - var metadata = new McpTaskMetadata(); - var created = await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - - // Act - var retrieved = await store.GetTaskAsync(created.TaskId, null, TestContext.Current.CancellationToken); - - // Assert - Assert.NotNull(retrieved); - Assert.Equal(created.TaskId, retrieved.TaskId); - Assert.Equal(created.Status, retrieved.Status); - } + var store = new InMemoryMcpTaskStore(); + var created = await store.CreateTaskAsync(CT); - [Fact] - public async Task GetTaskAsync_ReturnsNullForNonexistentTask() - { - // Arrange - using var store = new InMemoryMcpTaskStore(); - - // Act - var task = await store.GetTaskAsync("nonexistent-id", null, TestContext.Current.CancellationToken); + var result = await store.GetTaskAsync(created.TaskId, CT); - // Assert - Assert.Null(task); + Assert.NotNull(result); + Assert.Equal(McpTaskStatus.Working, result.Status); + Assert.Equal(created.TaskId, result.TaskId); } [Fact] - public async Task GetTaskAsync_EnforcesSessionIsolation() + public async Task GetTaskAsync_ReturnsNullForUnknownId() { - // Arrange - using var store = new InMemoryMcpTaskStore(); - var metadata = new McpTaskMetadata(); - var task = await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, "session-1", TestContext.Current.CancellationToken); - - // Act - var sameSession = await store.GetTaskAsync(task.TaskId, "session-1", TestContext.Current.CancellationToken); - var differentSession = await store.GetTaskAsync(task.TaskId, "session-2", TestContext.Current.CancellationToken); - - // Assert - Assert.NotNull(sameSession); - Assert.Null(differentSession); - } + var store = new InMemoryMcpTaskStore(); - [Fact] - public async Task StoreTaskResultAsync_StoresResultForCompletedTask() - { - // Arrange - using var store = new InMemoryMcpTaskStore(); - var metadata = new McpTaskMetadata(); - var task = await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - var result = new CallToolResult { Content = [new TextContentBlock { Text = "Success" }] }; - var resultElement = JsonSerializer.SerializeToElement(result, McpJsonUtilities.DefaultOptions); - - // Act - await store.StoreTaskResultAsync(task.TaskId, McpTaskStatus.Completed, resultElement, null, TestContext.Current.CancellationToken); - - // Assert - var retrieved = await store.GetTaskAsync(task.TaskId, null, TestContext.Current.CancellationToken); - Assert.Equal(McpTaskStatus.Completed, retrieved!.Status); - } + var result = await store.GetTaskAsync("nonexistent", CT); - [Fact] - public async Task StoreTaskResultAsync_EnforcesSessionIsolation() - { - // Arrange - using var store = new InMemoryMcpTaskStore(); - var metadata = new McpTaskMetadata(); - var task = await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, "session-1", TestContext.Current.CancellationToken); - var result = new CallToolResult { Content = [new TextContentBlock { Text = "Success" }] }; - var resultElement = JsonSerializer.SerializeToElement(result, McpJsonUtilities.DefaultOptions); - - // Act & Assert - await Assert.ThrowsAsync( - () => store.StoreTaskResultAsync(task.TaskId, McpTaskStatus.Completed, resultElement, "session-2", TestContext.Current.CancellationToken)); + Assert.Null(result); } [Fact] - public async Task StoreTaskResultAsync_ThrowsForNonTerminalStatus() + public async Task GetTaskAsync_WithinTimeToLive_ReturnsTask() { - // Arrange - using var store = new InMemoryMcpTaskStore(); - var metadata = new McpTaskMetadata(); - var task = await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - var result = new CallToolResult { Content = [new TextContentBlock { Text = "Success" }] }; - var resultElement = JsonSerializer.SerializeToElement(result, McpJsonUtilities.DefaultOptions); - - // Act & Assert - await Assert.ThrowsAsync( - () => store.StoreTaskResultAsync(task.TaskId, McpTaskStatus.Working, resultElement, null, TestContext.Current.CancellationToken)); - } + var store = new InMemoryMcpTaskStore { DefaultTimeToLive = TimeSpan.FromMinutes(10) }; + var created = await store.CreateTaskAsync(CT); - [Fact] - public async Task GetTaskResultAsync_ReturnsStoredResult() - { - // Arrange - using var store = new InMemoryMcpTaskStore(); - var metadata = new McpTaskMetadata(); - var task = await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - var result = new CallToolResult { Content = [new TextContentBlock { Text = "Success" }] }; - var resultElement = JsonSerializer.SerializeToElement(result, McpJsonUtilities.DefaultOptions); - await store.StoreTaskResultAsync(task.TaskId, McpTaskStatus.Completed, resultElement, null, TestContext.Current.CancellationToken); - - // Act - var retrieved = await store.GetTaskResultAsync(task.TaskId, null, TestContext.Current.CancellationToken); - - // Assert - var callToolResult = retrieved.Deserialize(McpJsonUtilities.DefaultOptions)!; - Assert.Single(callToolResult.Content); - Assert.Equal("Success", ((TextContentBlock)callToolResult.Content[0]).Text); - } + var result = await store.GetTaskAsync(created.TaskId, CT); - [Fact] - public async Task GetTaskResultAsync_EnforcesSessionIsolation() - { - // Arrange - using var store = new InMemoryMcpTaskStore(); - var metadata = new McpTaskMetadata(); - var task = await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, "session-1", TestContext.Current.CancellationToken); - var result = new CallToolResult { Content = [new TextContentBlock { Text = "Success" }] }; - var resultElement = JsonSerializer.SerializeToElement(result, McpJsonUtilities.DefaultOptions); - await store.StoreTaskResultAsync(task.TaskId, McpTaskStatus.Completed, resultElement, "session-1", TestContext.Current.CancellationToken); - - // Act & Assert - await Assert.ThrowsAsync( - () => store.GetTaskResultAsync(task.TaskId, "session-2", TestContext.Current.CancellationToken)); + Assert.NotNull(result); + Assert.Equal(created.TaskId, result.TaskId); } [Fact] - public async Task UpdateTaskStatusAsync_UpdatesStatus() + public async Task GetTaskAsync_AfterTimeToLiveElapsed_ReturnsNull() { - // Arrange - using var store = new InMemoryMcpTaskStore(); - var metadata = new McpTaskMetadata(); - var task = await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - - // Act - await store.UpdateTaskStatusAsync(task.TaskId, McpTaskStatus.Working, "Processing...", null, TestContext.Current.CancellationToken); - - // Assert - var updated = await store.GetTaskAsync(task.TaskId, null, TestContext.Current.CancellationToken); - Assert.Equal(McpTaskStatus.Working, updated!.Status); - Assert.Equal("Processing...", updated.StatusMessage); - } + var store = new InMemoryMcpTaskStore { DefaultTimeToLive = TimeSpan.FromMilliseconds(100) }; + var created = await store.CreateTaskAsync(CT); - [Fact] - public async Task UpdateTaskStatusAsync_UpdatesLastUpdatedAt() - { - // Arrange - Use FakeTimeProvider for deterministic testing - var fakeTime = new FakeTimeProvider(DateTimeOffset.UtcNow); - using var store = new TestInMemoryMcpTaskStore( - defaultTtl: null, - maxTtl: null, - pollInterval: null, - cleanupInterval: Timeout.InfiniteTimeSpan, - pageSize: 100, - maxTasks: null, - maxTasksPerSession: null, - timeProvider: fakeTime); - - var metadata = new McpTaskMetadata(); - var task = await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - var originalTimestamp = task.LastUpdatedAt; - - // Advance time to ensure timestamp changes - fakeTime.Advance(TimeSpan.FromMilliseconds(10)); - - // Act - await store.UpdateTaskStatusAsync(task.TaskId, McpTaskStatus.Working, null, null, TestContext.Current.CancellationToken); - - // Assert - var updated = await store.GetTaskAsync(task.TaskId, null, TestContext.Current.CancellationToken); - Assert.True(updated!.LastUpdatedAt > originalTimestamp); - } + await Task.Delay(TimeSpan.FromMilliseconds(500), CT); - #region Input Required Status Tests + var result = await store.GetTaskAsync(created.TaskId, CT); - // NOTE: The InputRequired status is automatically set by the server when a tool executing - // as a task calls SampleAsync() or ElicitAsync(). The status is set back to Working when - // the request completes. See TaskExecutionContext for implementation details. - // The tests below verify the store correctly handles status transitions. + Assert.Null(result); + } [Fact] - public async Task InputRequiredStatus_SerializesCorrectly() + public async Task GetTaskAsync_WithoutTimeToLive_DoesNotExpire() { - // Verify the input_required status serializes as expected - var task = new McpTask - { - TaskId = "test-task", - Status = McpTaskStatus.InputRequired, - StatusMessage = "Waiting for user input", - CreatedAt = DateTimeOffset.UtcNow, - LastUpdatedAt = DateTimeOffset.UtcNow - }; + var store = new InMemoryMcpTaskStore(); + var created = await store.CreateTaskAsync(CT); - string json = JsonSerializer.Serialize(task, McpJsonUtilities.DefaultOptions); + await Task.Delay(TimeSpan.FromMilliseconds(200), CT); - Assert.Contains("\"status\":\"input_required\"", json); - } + var result = await store.GetTaskAsync(created.TaskId, CT); - [Fact] - public async Task InputRequiredStatus_CanTransitionToWorking() - { - // Arrange - Spec: "From input_required: may move to working, completed, failed, or cancelled" - using var store = new InMemoryMcpTaskStore(); - var metadata = new McpTaskMetadata(); - var task = await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - - // Transition to input_required (testing store's status transition capability) - var inputRequiredTask = await store.UpdateTaskStatusAsync( - task.TaskId, - McpTaskStatus.InputRequired, - "Waiting for user confirmation", - cancellationToken: TestContext.Current.CancellationToken); - - Assert.Equal(McpTaskStatus.InputRequired, inputRequiredTask.Status); - - // Act - Transition back to working - var workingTask = await store.UpdateTaskStatusAsync( - task.TaskId, - McpTaskStatus.Working, - "Processing resumed", - cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Assert.Equal(McpTaskStatus.Working, workingTask.Status); + Assert.NotNull(result); + Assert.Equal(created.TaskId, result.TaskId); } [Fact] - public async Task InputRequiredStatus_CanTransitionToCancelled() + public async Task GetTaskAsync_WithZeroTimeToLive_DoesNotExpire() { - // Arrange - Spec: Task transitions show input_required can go to terminal states - using var store = new InMemoryMcpTaskStore(); - var metadata = new McpTaskMetadata(); - var task = await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - - // Transition to input_required - await store.UpdateTaskStatusAsync( - task.TaskId, - McpTaskStatus.InputRequired, - "Need input", - cancellationToken: TestContext.Current.CancellationToken); - - // Act - Transition to cancelled - var cancelledTask = await store.CancelTaskAsync( - task.TaskId, - cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Assert.Equal(McpTaskStatus.Cancelled, cancelledTask.Status); - } + var store = new InMemoryMcpTaskStore { DefaultTimeToLive = TimeSpan.Zero }; + var created = await store.CreateTaskAsync(CT); - #endregion + await Task.Delay(TimeSpan.FromMilliseconds(200), CT); - [Fact] - public async Task ListTasksAsync_ReturnsAllTasks() - { - // Arrange - using var store = new InMemoryMcpTaskStore(); - var task1 = await store.CreateTaskAsync(new McpTaskMetadata(), new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - var task2 = await store.CreateTaskAsync(new McpTaskMetadata(), new RequestId("req-2"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - - // Act - var result = await store.ListTasksAsync(cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Assert.Equal(2, result.Tasks.Count); - Assert.Contains(result.Tasks, t => t.TaskId == task1.TaskId); - Assert.Contains(result.Tasks, t => t.TaskId == task2.TaskId); - Assert.Null(result.NextCursor); - } + var result = await store.GetTaskAsync(created.TaskId, CT); - [Fact] - public async Task ListTasksAsync_FiltersBySession() - { - // Arrange - using var store = new InMemoryMcpTaskStore(); - var task1 = await store.CreateTaskAsync(new McpTaskMetadata(), new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, "session-1", TestContext.Current.CancellationToken); - var task2 = await store.CreateTaskAsync(new McpTaskMetadata(), new RequestId("req-2"), new JsonRpcRequest { Method = "test" }, "session-2", TestContext.Current.CancellationToken); - - // Act - var session1Result = await store.ListTasksAsync(sessionId: "session-1", cancellationToken: TestContext.Current.CancellationToken); - var session2Result = await store.ListTasksAsync(sessionId: "session-2", cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Assert.Single(session1Result.Tasks); - Assert.Equal(task1.TaskId, session1Result.Tasks[0].TaskId); - Assert.Single(session2Result.Tasks); - Assert.Equal(task2.TaskId, session2Result.Tasks[0].TaskId); + Assert.NotNull(result); + Assert.Equal(created.TaskId, result.TaskId); } [Fact] - public async Task ListTasksAsync_SupportsPagination() + public async Task SetCompletedAsync_TransitionsToCompleted() { - // Arrange - using var store = new InMemoryMcpTaskStore(); - - // Create 150 tasks (more than page size of 100) - for (int i = 0; i < 150; i++) - { - await store.CreateTaskAsync(new McpTaskMetadata(), new RequestId($"req-{i}"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - } - - // Act - First page - var firstPageResult = await store.ListTasksAsync(cancellationToken: TestContext.Current.CancellationToken); - - // Act - Second page - var secondPageResult = await store.ListTasksAsync(cursor: firstPageResult.NextCursor, cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Assert.Equal(100, firstPageResult.Tasks.Count); - Assert.NotNull(firstPageResult.NextCursor); - Assert.Equal(50, secondPageResult.Tasks.Count); - Assert.Null(secondPageResult.NextCursor); - } + var store = new InMemoryMcpTaskStore(); + var created = await store.CreateTaskAsync(CT); + var resultPayload = JsonDocument.Parse("""{"answer":42}""").RootElement.Clone(); - [Fact] - public async Task CancelTaskAsync_CancelsTask() - { - // Arrange - using var store = new InMemoryMcpTaskStore(); - var metadata = new McpTaskMetadata(); - var task = await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); + await store.SetCompletedAsync(created.TaskId, resultPayload, CT); - // Act - var cancelled = await store.CancelTaskAsync(task.TaskId, null, TestContext.Current.CancellationToken); - - // Assert - Assert.Equal(McpTaskStatus.Cancelled, cancelled.Status); + var task = await store.GetTaskAsync(created.TaskId, CT); + Assert.NotNull(task); + Assert.Equal(McpTaskStatus.Completed, task.Status); + Assert.Equal(42, task.Result!.Value.GetProperty("answer").GetInt32()); } [Fact] - public async Task CancelTaskAsync_IsIdempotent() + public async Task SetFailedAsync_TransitionsToFailed() { - // Arrange - using var store = new InMemoryMcpTaskStore(); - var metadata = new McpTaskMetadata(); - var task = await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - - // First cancellation - await store.CancelTaskAsync(task.TaskId, null, TestContext.Current.CancellationToken); - - // Act - Second cancellation - var result = await store.CancelTaskAsync(task.TaskId, null, TestContext.Current.CancellationToken); - - // Assert - Should return unchanged task, not throw - Assert.Equal(McpTaskStatus.Cancelled, result.Status); - } + var store = new InMemoryMcpTaskStore(); + var created = await store.CreateTaskAsync(CT); + var errorPayload = JsonDocument.Parse("""{"message":"boom"}""").RootElement.Clone(); - [Fact] - public async Task CancelTaskAsync_DoesNotCancelCompletedTask() - { - // Arrange - using var store = new InMemoryMcpTaskStore(); - var metadata = new McpTaskMetadata(); - var task = await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - var result = new CallToolResult { Content = [new TextContentBlock { Text = "Success" }] }; - var resultElement = JsonSerializer.SerializeToElement(result, McpJsonUtilities.DefaultOptions); - await store.StoreTaskResultAsync(task.TaskId, McpTaskStatus.Completed, resultElement, null, TestContext.Current.CancellationToken); - - // Act - var cancelResult = await store.CancelTaskAsync(task.TaskId, null, TestContext.Current.CancellationToken); - - // Assert - Task remains completed - Assert.Equal(McpTaskStatus.Completed, cancelResult.Status); + await store.SetFailedAsync(created.TaskId, errorPayload, CT); + + var task = await store.GetTaskAsync(created.TaskId, CT); + Assert.NotNull(task); + Assert.Equal(McpTaskStatus.Failed, task.Status); + Assert.Equal("boom", task.Error!.Value.GetProperty("message").GetString()); } [Fact] - public async Task CancelTaskAsync_EnforcesSessionIsolation() + public async Task SetCancelledAsync_TransitionsToCancelled() { - // Arrange - using var store = new InMemoryMcpTaskStore(); - var metadata = new McpTaskMetadata(); - var task = await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, "session-1", TestContext.Current.CancellationToken); + var store = new InMemoryMcpTaskStore(); + var created = await store.CreateTaskAsync(CT); - // Act & Assert - await Assert.ThrowsAsync( - () => store.CancelTaskAsync(task.TaskId, "session-2", TestContext.Current.CancellationToken)); - } + var cancelled = await store.SetCancelledAsync(created.TaskId, CT); - [Fact] - public async Task Dispose_StopsCleanupTimer() - { - // Arrange - Use FakeTimeProvider for deterministic testing - var fakeTime = new FakeTimeProvider(DateTimeOffset.UtcNow); - var cleanupInterval = TimeSpan.FromMilliseconds(100); - - var store = new TestInMemoryMcpTaskStore( - defaultTtl: null, - maxTtl: null, - pollInterval: null, - cleanupInterval: cleanupInterval, - pageSize: 100, - maxTasks: null, - maxTasksPerSession: null, - timeProvider: fakeTime); - - var metadata = new McpTaskMetadata { TimeToLive = TimeSpan.FromMilliseconds(100) }; - await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - - // Act - store.Dispose(); - - // Advance time - timer should not fire after dispose - fakeTime.Advance(TimeSpan.FromTicks(cleanupInterval.Ticks * 3)); - - // Assert - Store should still be accessible after dispose (no exceptions) - // The cleanup timer should have stopped - Assert.True(true); // If we get here without exceptions, dispose worked + Assert.True(cancelled); + var task = await store.GetTaskAsync(created.TaskId, CT); + Assert.NotNull(task); + Assert.Equal(McpTaskStatus.Cancelled, task.Status); } [Fact] - public async Task CleanupExpiredTasks_RemovesExpiredTasks() + public async Task SetCancelledAsync_ReturnsFalseForTerminalTask() { - // Arrange - Use FakeTimeProvider for deterministic testing - var fakeTime = new FakeTimeProvider(DateTimeOffset.UtcNow); - var cleanupInterval = TimeSpan.FromMilliseconds(50); - var ttl = TimeSpan.FromMilliseconds(100); - - using var store = new TestInMemoryMcpTaskStore( - defaultTtl: null, - maxTtl: null, - pollInterval: null, - cleanupInterval: cleanupInterval, - pageSize: 100, - maxTasks: null, - maxTasksPerSession: null, - timeProvider: fakeTime); - - var metadata = new McpTaskMetadata { TimeToLive = ttl }; - var task = await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - - // Verify task exists initially - var resultBefore = await store.ListTasksAsync(cancellationToken: TestContext.Current.CancellationToken); - Assert.Single(resultBefore.Tasks); - - // Advance time past the TTL to make task expired - fakeTime.Advance(ttl + TimeSpan.FromMilliseconds(1)); - - // Trigger cleanup by advancing time past cleanup interval - fakeTime.Advance(cleanupInterval); - - // Act - List tasks to verify cleanup happened - var resultAfter = await store.ListTasksAsync(cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Assert.Empty(resultAfter.Tasks); // Task should be cleaned up by the timer + var store = new InMemoryMcpTaskStore(); + var created = await store.CreateTaskAsync(CT); + await store.SetCompletedAsync(created.TaskId, JsonSerializer.SerializeToElement("done", McpJsonUtilities.DefaultOptions), CT); + + var cancelled = await store.SetCancelledAsync(created.TaskId, CT); + + Assert.False(cancelled); + var task = await store.GetTaskAsync(created.TaskId, CT); + Assert.NotNull(task); + Assert.Equal(McpTaskStatus.Completed, task.Status); } [Fact] - public async Task DefaultTtl_AppliedWhenNoTtlSpecified() + public async Task SetCancelledAsync_ReturnsFalseForUnknownId() { - // Arrange - var defaultTtl = TimeSpan.FromMinutes(10); - using var store = new InMemoryMcpTaskStore(defaultTtl: defaultTtl); - var metadata = new McpTaskMetadata(); // No TTL specified + var store = new InMemoryMcpTaskStore(); - // Act - var task = await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); + var cancelled = await store.SetCancelledAsync("nonexistent", CT); - // Assert - Assert.Equal(defaultTtl, task.TimeToLive); + Assert.False(cancelled); } [Fact] - public async Task MultipleOperations_ConcurrentAccess() + public async Task SetInputRequestsAsync_TransitionsToInputRequired() { - // Arrange - using var store = new InMemoryMcpTaskStore(); - var tasks = new List>(); + var store = new InMemoryMcpTaskStore(); + var created = await store.CreateTaskAsync(CT); - // Act - Create multiple tasks concurrently - for (int i = 0; i < 10; i++) + var requests = new Dictionary { - int taskNum = i; - tasks.Add(Task.Run(async () => + ["req1"] = new InputRequest { - var metadata = new McpTaskMetadata(); - return await store.CreateTaskAsync(metadata, new RequestId($"req-{taskNum}"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - })); - } - - var createdTasks = await Task.WhenAll(tasks); - - // Assert - All tasks should be created with unique IDs - Assert.Equal(10, createdTasks.Length); - Assert.Equal(10, createdTasks.Select(t => t.TaskId).Distinct().Count()); - } + Method = "elicitation/create", + Params = JsonElement.Parse("""{"message":"hello"}"""), + }, + }; + await store.SetInputRequestsAsync(created.TaskId, requests, CT); - [Fact] - public void Constructor_ThrowsWhenDefaultTtlExceedsMaxTtl() - { - // Arrange & Act & Assert - var exception = Assert.Throws(() => - new InMemoryMcpTaskStore( - defaultTtl: TimeSpan.FromHours(2), - maxTtl: TimeSpan.FromHours(1))); - - Assert.Equal("defaultTtl", exception.ParamName); - Assert.Contains("Default TTL", exception.Message); - Assert.Contains("cannot exceed maximum TTL", exception.Message); + var task = await store.GetTaskAsync(created.TaskId, CT); + Assert.NotNull(task); + Assert.Equal(McpTaskStatus.InputRequired, task.Status); + Assert.NotNull(task.InputRequests); + Assert.Single(task.InputRequests); + Assert.True(task.InputRequests.ContainsKey("req1")); } [Fact] - public async Task CreateTaskAsync_UsesConfiguredPollInterval() + public async Task SetInputRequestsAsync_MergesMultipleRequests() { - // Arrange - using var store = new InMemoryMcpTaskStore(pollInterval: TimeSpan.FromMilliseconds(2500)); - var metadata = new McpTaskMetadata(); + var store = new InMemoryMcpTaskStore(); + var created = await store.CreateTaskAsync(CT); - // Act - var task = await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); + await store.SetInputRequestsAsync(created.TaskId, new Dictionary + { + ["req1"] = MakeRequest("first") + }, CT); + await store.SetInputRequestsAsync(created.TaskId, new Dictionary + { + ["req2"] = MakeRequest("second") + }, CT); - // Assert - Assert.Equal(TimeSpan.FromMilliseconds(2500), task.PollInterval); + var task = await store.GetTaskAsync(created.TaskId, CT); + Assert.NotNull(task); + Assert.Equal(McpTaskStatus.InputRequired, task.Status); + Assert.NotNull(task.InputRequests); + Assert.Equal(2, task.InputRequests.Count); + Assert.True(task.InputRequests.ContainsKey("req1")); + Assert.True(task.InputRequests.ContainsKey("req2")); } [Fact] - public void Constructor_ThrowsWhenPollIntervalIsZero() + public async Task ResolveInputRequestsAsync_RemovesMatchedRequests() { - // Arrange & Act & Assert - var exception = Assert.Throws(() => - new InMemoryMcpTaskStore(pollInterval: TimeSpan.Zero)); + var store = new InMemoryMcpTaskStore(); + var created = await store.CreateTaskAsync(CT); - Assert.Equal("pollInterval", exception.ParamName); - Assert.Contains("Poll interval must be positive", exception.Message); - } + await store.SetInputRequestsAsync(created.TaskId, new Dictionary + { + ["req1"] = MakeRequest("request1"), + ["req2"] = MakeRequest("request2"), + }, CT); - [Fact] - public void Constructor_ThrowsWhenPollIntervalIsNegative() - { - // Arrange & Act & Assert - var exception = Assert.Throws(() => - new InMemoryMcpTaskStore(pollInterval: TimeSpan.FromMilliseconds(-100))); + await store.ResolveInputRequestsAsync(created.TaskId, new Dictionary + { + ["req1"] = MakeResponse("response1"), + }, CT); - Assert.Equal("pollInterval", exception.ParamName); - Assert.Contains("Poll interval must be positive", exception.Message); + var task = await store.GetTaskAsync(created.TaskId, CT); + Assert.NotNull(task); + Assert.Equal(McpTaskStatus.InputRequired, task.Status); + Assert.NotNull(task.InputRequests); + Assert.Single(task.InputRequests); + Assert.True(task.InputRequests.ContainsKey("req2")); } [Fact] - public async Task GetTaskAsync_ReturnsDefensiveCopy() + public async Task ResolveInputRequestsAsync_TransitionsToWorkingWhenAllSatisfied() { - // Arrange - using var store = new InMemoryMcpTaskStore(); - var metadata = new McpTaskMetadata(); - var createdTask = await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - - // Act - Get the task and modify the returned copy - var retrievedTask = await store.GetTaskAsync(createdTask.TaskId, null, TestContext.Current.CancellationToken); - var originalStatus = retrievedTask!.Status; - retrievedTask.Status = McpTaskStatus.Completed; - retrievedTask.StatusMessage = "Modified externally"; - - // Assert - Get the task again and verify the stored state wasn't affected - var taskAgain = await store.GetTaskAsync(createdTask.TaskId, null, TestContext.Current.CancellationToken); - Assert.Equal(originalStatus, taskAgain!.Status); - Assert.Null(taskAgain.StatusMessage); - } + var store = new InMemoryMcpTaskStore(); + var created = await store.CreateTaskAsync(CT); - [Fact] - public async Task ListTasksAsync_ReturnsDefensiveCopies() - { - // Arrange - using var store = new InMemoryMcpTaskStore(); - var metadata = new McpTaskMetadata(); - await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - - // Act - List tasks and modify the returned copies - var result = await store.ListTasksAsync(cancellationToken: TestContext.Current.CancellationToken); - var firstTask = result.Tasks[0]; - var originalTaskId = firstTask.TaskId; - firstTask.Status = McpTaskStatus.Failed; - firstTask.StatusMessage = "Modified in list"; - - // Assert - Get the task directly and verify the stored state wasn't affected - var directTask = await store.GetTaskAsync(originalTaskId, null, TestContext.Current.CancellationToken); - Assert.Equal(McpTaskStatus.Working, directTask!.Status); - Assert.Null(directTask.StatusMessage); - } + await store.SetInputRequestsAsync(created.TaskId, new Dictionary + { + ["req1"] = MakeRequest("request1"), + }, CT); - [Fact] - public async Task CancelTaskAsync_ReturnsDefensiveCopy() - { - // Arrange - using var store = new InMemoryMcpTaskStore(); - var metadata = new McpTaskMetadata(); - var createdTask = await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - - // Act - Cancel the task and modify the returned copy - var cancelledTask = await store.CancelTaskAsync(createdTask.TaskId, null, TestContext.Current.CancellationToken); - cancelledTask.StatusMessage = "Modified after cancel"; - cancelledTask.Status = McpTaskStatus.Completed; - - // Assert - Get the task again and verify it's still cancelled with no message - var taskAgain = await store.GetTaskAsync(createdTask.TaskId, null, TestContext.Current.CancellationToken); - Assert.Equal(McpTaskStatus.Cancelled, taskAgain!.Status); - Assert.Null(taskAgain.StatusMessage); + await store.ResolveInputRequestsAsync(created.TaskId, new Dictionary + { + ["req1"] = MakeResponse("response1"), + }, CT); + + var task = await store.GetTaskAsync(created.TaskId, CT); + Assert.NotNull(task); + Assert.Equal(McpTaskStatus.Working, task.Status); } [Fact] - public async Task ConcurrentUpdates_HandlesContentionCorrectly() + public async Task SetCompletedAsync_ThrowsForUnknownTask() { - // Arrange - using var store = new InMemoryMcpTaskStore(); - var task = await store.CreateTaskAsync(new McpTaskMetadata(), new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); + var store = new InMemoryMcpTaskStore(); - // Act - Launch 100 concurrent updates to the same task - var updateTasks = Enumerable.Range(0, 100).Select(i => - Task.Run(async () => - { - try - { - await store.UpdateTaskStatusAsync(task.TaskId, McpTaskStatus.Working, $"Update {i}", null, TestContext.Current.CancellationToken); - return true; - } - catch - { - return false; - } - })); - - var results = await Task.WhenAll(updateTasks); - - // Assert - All updates should succeed (retry loop handles contention) - Assert.All(results, success => Assert.True(success)); - - // Verify task is still in valid state (one of the updates won) - var finalTask = await store.GetTaskAsync(task.TaskId, null, TestContext.Current.CancellationToken); - Assert.NotNull(finalTask); - Assert.Equal(McpTaskStatus.Working, finalTask.Status); - Assert.Matches(@"Update \d+", finalTask.StatusMessage!); + await Assert.ThrowsAsync( + () => store.SetCompletedAsync("nonexistent", JsonSerializer.SerializeToElement("x", McpJsonUtilities.DefaultOptions), CT)); } [Fact] - public async Task ConcurrentStoreResult_OnlyFirstWins() + public async Task ConcurrentUpdates_DoNotLoseData() { - // Arrange - using var store = new InMemoryMcpTaskStore(); - var task = await store.CreateTaskAsync(new McpTaskMetadata(), new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); + var store = new InMemoryMcpTaskStore(); + var created = await store.CreateTaskAsync(CT); - // Act - Try to store results concurrently (only first should succeed) - var storeTasks = Enumerable.Range(0, 10).Select(i => - Task.Run(async () => + var tasks = Enumerable.Range(0, 50).Select(i => + store.SetInputRequestsAsync(created.TaskId, new Dictionary { - try - { - var result = new CallToolResult { Content = [new TextContentBlock { Text = $"Result {i}" }] }; - var resultElement = JsonSerializer.SerializeToElement(result, McpJsonUtilities.DefaultOptions); - await store.StoreTaskResultAsync( - task.TaskId, - McpTaskStatus.Completed, - resultElement, - null, - TestContext.Current.CancellationToken); - return i; - } - catch (InvalidOperationException) - { - // Expected: task already in terminal state - return -1; - } - })); - - var results = await Task.WhenAll(storeTasks); - var successfulUpdates = results.Where(r => r >= 0).ToList(); - - // Assert - Exactly one update should succeed, others should fail - Assert.Single(successfulUpdates); - - // Verify the winning result is stored - var finalTask = await store.GetTaskAsync(task.TaskId, null, TestContext.Current.CancellationToken); - Assert.Equal(McpTaskStatus.Completed, finalTask!.Status); + [$"req{i}"] = MakeRequest($"value{i}") + }, CT)); + + await Task.WhenAll(tasks); + + var task = await store.GetTaskAsync(created.TaskId, CT); + Assert.NotNull(task); + Assert.Equal(McpTaskStatus.InputRequired, task.Status); + Assert.NotNull(task.InputRequests); + Assert.Equal(50, task.InputRequests.Count); } [Fact] - public async Task ListTasksAsync_PaginationWithCustomPageSize() + public async Task ResolveInputRequestsAsync_ForExtraKeys_DoesNotThrow() { - // Arrange - Use small page size for testing - using var store = new InMemoryMcpTaskStore(pageSize: 10); + var store = new InMemoryMcpTaskStore(); + var created = await store.CreateTaskAsync(CT); - // Create 25 tasks - for (int i = 0; i < 25; i++) + await store.ResolveInputRequestsAsync(created.TaskId, new Dictionary { - await store.CreateTaskAsync(new McpTaskMetadata(), new RequestId($"req-{i}"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - } - - // Act - Paginate through all tasks - var result1 = await store.ListTasksAsync(cancellationToken: TestContext.Current.CancellationToken); - var result2 = await store.ListTasksAsync(cursor: result1.NextCursor, cancellationToken: TestContext.Current.CancellationToken); - var result3 = await store.ListTasksAsync(cursor: result2.NextCursor, cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Assert.Equal(10, result1.Tasks.Count); - Assert.NotNull(result1.NextCursor); - Assert.Equal(10, result2.Tasks.Count); - Assert.NotNull(result2.NextCursor); - Assert.Equal(5, result3.Tasks.Count); - Assert.Null(result3.NextCursor); - - // Verify no duplicates across pages - var allTaskIds = result1.Tasks.Concat(result2.Tasks).Concat(result3.Tasks).Select(t => t.TaskId).ToList(); - Assert.Equal(25, allTaskIds.Distinct().Count()); + ["unknown-key"] = MakeResponse("response"), + }, CT); + + var task = await store.GetTaskAsync(created.TaskId, CT); + Assert.NotNull(task); + Assert.Equal(McpTaskStatus.Working, task.Status); } [Fact] - public async Task ListTasksAsync_NoDuplicatesWithIdenticalTimestamps() + public async Task ResolveInputRequestsAsync_AlreadyResolvedKey_IsNoOp() { - // Arrange - using var store = new InMemoryMcpTaskStore(pageSize: 5); - - // Create tasks with identical metadata to increase chance of timestamp collision - var createTasks = Enumerable.Range(0, 20).Select(i => - store.CreateTaskAsync(new McpTaskMetadata(), new RequestId($"req-{i}"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken)); - - await Task.WhenAll(createTasks); + // SEP-2663: "Each entry key SHOULD be unique across the lifetime of a given task" and + // servers should tolerate clients re-sending an inputResponse for an already-resolved key. + var store = new InMemoryMcpTaskStore(); + var created = await store.CreateTaskAsync(CT); + await store.SetInputRequestsAsync(created.TaskId, new Dictionary + { + ["a"] = MakeRequest("ask-a"), + ["b"] = MakeRequest("ask-b"), + }, CT); - // Act - Collect all tasks through pagination - var allTasks = new List(); - string? cursor = null; - do + // First resolve "a" — task should still be InputRequired because "b" remains. + await store.ResolveInputRequestsAsync(created.TaskId, new Dictionary + { + ["a"] = MakeResponse("answer-a"), + }, CT); + + var afterFirst = await store.GetTaskAsync(created.TaskId, CT); + Assert.NotNull(afterFirst); + Assert.Equal(McpTaskStatus.InputRequired, afterFirst.Status); + Assert.NotNull(afterFirst.InputRequests); + Assert.Single(afterFirst.InputRequests); + Assert.Contains("b", afterFirst.InputRequests.Keys); + + // Re-send "a" — should be a no-op (no exception, no state change). + await store.ResolveInputRequestsAsync(created.TaskId, new Dictionary + { + ["a"] = MakeResponse("answer-a-again"), + }, CT); + + var afterDup = await store.GetTaskAsync(created.TaskId, CT); + Assert.NotNull(afterDup); + Assert.Equal(McpTaskStatus.InputRequired, afterDup.Status); + Assert.NotNull(afterDup.InputRequests); + Assert.Single(afterDup.InputRequests); + Assert.Contains("b", afterDup.InputRequests.Keys); + + // Resolve the remaining "b" — task should transition back to Working with an empty inputRequests. + await store.ResolveInputRequestsAsync(created.TaskId, new Dictionary { - var result = await store.ListTasksAsync(cursor: cursor, cancellationToken: TestContext.Current.CancellationToken); - allTasks.AddRange(result.Tasks); - cursor = result.NextCursor; - } while (cursor != null); - - // Assert - No duplicates - var taskIds = allTasks.Select(t => t.TaskId).ToList(); - Assert.Equal(20, taskIds.Count); - Assert.Equal(20, taskIds.Distinct().Count()); - - // Verify tasks are properly ordered - Assert.Equal(allTasks.OrderBy(t => t.CreatedAt).ThenBy(t => t.TaskId).Select(t => t.TaskId), taskIds); + ["b"] = MakeResponse("answer-b"), + }, CT); + + var final = await store.GetTaskAsync(created.TaskId, CT); + Assert.NotNull(final); + Assert.Equal(McpTaskStatus.Working, final.Status); + Assert.True(final.InputRequests is null || final.InputRequests.Count == 0); } [Fact] - public async Task ListTasksAsync_ConsistentWithExpiredTasksRemovedBetweenPages() + public async Task ConcurrentResolveInputRequests_OnDisjointKeys_AllResolveCorrectly() { - // Arrange - Use FakeTimeProvider for deterministic testing - var fakeTime = new FakeTimeProvider(DateTimeOffset.UtcNow); - var ttl = TimeSpan.FromSeconds(1); - using var store = new TestInMemoryMcpTaskStore( - defaultTtl: ttl, - maxTtl: null, - pollInterval: null, - cleanupInterval: Timeout.InfiniteTimeSpan, - pageSize: 5, - maxTasks: null, - maxTasksPerSession: null, - timeProvider: fakeTime); - - // Create 15 tasks - for (int i = 0; i < 15; i++) - { - await store.CreateTaskAsync(new McpTaskMetadata(), new RequestId($"req-{i}"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - } + // Verifies the optimistic-concurrency loop in InMemoryMcpTaskStore handles parallel + // tasks/update calls that each resolve a distinct subset of pending input requests. + var store = new InMemoryMcpTaskStore(); + var created = await store.CreateTaskAsync(CT); - // Act - Get first page immediately - var result1 = await store.ListTasksAsync(cancellationToken: TestContext.Current.CancellationToken); + var seed = Enumerable.Range(0, 20).ToDictionary( + i => $"req{i}", + i => MakeRequest($"ask{i}")); + await store.SetInputRequestsAsync(created.TaskId, seed, CT); - // Advance time past TTL to make tasks expire - fakeTime.Advance(ttl + TimeSpan.FromMilliseconds(500)); + var resolveTasks = Enumerable.Range(0, 20).Select(i => + store.ResolveInputRequestsAsync(created.TaskId, new Dictionary + { + [$"req{i}"] = MakeResponse($"answer{i}"), + }, CT)); - // Get second page after expiration - var result2 = await store.ListTasksAsync(cursor: result1.NextCursor, cancellationToken: TestContext.Current.CancellationToken); + await Task.WhenAll(resolveTasks); - // Assert - First page should have 5 tasks, second page should have 0 (all expired) - Assert.Equal(5, result1.Tasks.Count); - Assert.NotNull(result1.NextCursor); - Assert.Empty(result2.Tasks); - Assert.Null(result2.NextCursor); + var task = await store.GetTaskAsync(created.TaskId, CT); + Assert.NotNull(task); + Assert.Equal(McpTaskStatus.Working, task.Status); + Assert.True(task.InputRequests is null || task.InputRequests.Count == 0); } [Fact] - public async Task ListTasksAsync_KeysetPaginationMaintainsConsistencyWithNewTasks() + public async Task SetCompletedAsync_DoesNotOverwriteCancelledTask() { - // Arrange - using var store = new InMemoryMcpTaskStore(pageSize: 5); - - // Create 10 initial tasks - for (int i = 0; i < 10; i++) - { - await store.CreateTaskAsync(new McpTaskMetadata(), new RequestId($"req-{i}"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - } - - // Get first page - var result1 = await store.ListTasksAsync(cancellationToken: TestContext.Current.CancellationToken); - Assert.Equal(5, result1.Tasks.Count); - - // Add more tasks between pages (these should appear in later queries, not retroactively in page 2) - for (int i = 10; i < 15; i++) - { - await store.CreateTaskAsync(new McpTaskMetadata(), new RequestId($"req-{i}"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - } + var store = new InMemoryMcpTaskStore(); + var created = await store.CreateTaskAsync(CT); - // Get second page using cursor from before new tasks were added - var result2 = await store.ListTasksAsync(cursor: result1.NextCursor, cancellationToken: TestContext.Current.CancellationToken); + var cancelled = await store.SetCancelledAsync(created.TaskId, CT); + Assert.True(cancelled); - // Assert - Second page should have 5 tasks from original set - Assert.Equal(5, result2.Tasks.Count); - Assert.NotNull(result2.NextCursor); + // Background worker finishing after cancellation must not flip the task back to Completed. + await store.SetCompletedAsync( + created.TaskId, + JsonSerializer.SerializeToElement("late-result", McpJsonUtilities.DefaultOptions), + CT); - // Verify no overlap between pages - var page1Ids = result1.Tasks.Select(t => t.TaskId).ToHashSet(); - var page2Ids = result2.Tasks.Select(t => t.TaskId).ToHashSet(); - Assert.Empty(page1Ids.Intersect(page2Ids)); + var task = await store.GetTaskAsync(created.TaskId, CT); + Assert.NotNull(task); + Assert.Equal(McpTaskStatus.Cancelled, task.Status); + Assert.Null(task.Result); } [Fact] - public async Task UpdateTaskStatusAsync_ConcurrentWithList_NoCorruption() + public async Task SetFailedAsync_DoesNotOverwriteCancelledTask() { - // Arrange - using var store = new InMemoryMcpTaskStore(pageSize: 10); + var store = new InMemoryMcpTaskStore(); + var created = await store.CreateTaskAsync(CT); - // Create 20 tasks - var tasks = new List(); - for (int i = 0; i < 20; i++) - { - var task = await store.CreateTaskAsync(new McpTaskMetadata(), new RequestId($"req-{i}"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - tasks.Add(task); - } - - // Act - Concurrently list and update tasks - var ct = TestContext.Current.CancellationToken; - var listTask = Task.Run(async () => - { - var allTasks = new List(); - string? cursor = null; - do - { - var result = await store.ListTasksAsync(cursor: cursor, cancellationToken: TestContext.Current.CancellationToken); - allTasks.AddRange(result.Tasks); - cursor = result.NextCursor; - await Task.Delay(10, ct); // Small delay to increase chance of interleaving - } while (cursor != null); - return allTasks; - }, ct); - - var updateTask = Task.Run(async () => - { - foreach (var task in tasks) - { - await store.UpdateTaskStatusAsync(task.TaskId, McpTaskStatus.Working, "Updated", null, TestContext.Current.CancellationToken); - await Task.Delay(5, ct); // Small delay - } - }, ct); + await store.SetCancelledAsync(created.TaskId, CT); - await Task.WhenAll(listTask, updateTask); - var listedTasks = await listTask; + await store.SetFailedAsync( + created.TaskId, + JsonElement.Parse("""{"message":"boom"}"""), + CT); - // Assert - Should have listed all tasks without duplicates or corruption - Assert.Equal(20, listedTasks.Count); - Assert.Equal(20, listedTasks.Select(t => t.TaskId).Distinct().Count()); + var task = await store.GetTaskAsync(created.TaskId, CT); + Assert.NotNull(task); + Assert.Equal(McpTaskStatus.Cancelled, task.Status); + Assert.Null(task.Error); } [Fact] - public void Constructor_ThrowsForInvalidMaxTasks() + public async Task SetCompletedAsync_DoesNotOverwriteCompletedTask() { - // Assert - Assert.Throws(() => new InMemoryMcpTaskStore(maxTasks: 0)); - Assert.Throws(() => new InMemoryMcpTaskStore(maxTasks: -1)); - } + var store = new InMemoryMcpTaskStore(); + var created = await store.CreateTaskAsync(CT); - [Fact] - public void Constructor_ThrowsForInvalidMaxTasksPerSession() - { - // Assert - Assert.Throws(() => new InMemoryMcpTaskStore(maxTasksPerSession: 0)); - Assert.Throws(() => new InMemoryMcpTaskStore(maxTasksPerSession: -1)); - } + var first = JsonSerializer.SerializeToElement("first", McpJsonUtilities.DefaultOptions); + await store.SetCompletedAsync(created.TaskId, first, CT); - [Fact] - public async Task CreateTaskAsync_EnforcesMaxTasksLimit() - { - // Arrange - using var store = new InMemoryMcpTaskStore(maxTasks: 3); - var metadata = new McpTaskMetadata(); - - // Act - Create up to the limit - await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - await store.CreateTaskAsync(metadata, new RequestId("req-2"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - await store.CreateTaskAsync(metadata, new RequestId("req-3"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - - // Assert - Fourth task should throw - var ex = await Assert.ThrowsAsync(() => - store.CreateTaskAsync(metadata, new RequestId("req-4"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken)); - Assert.Contains("Maximum number of tasks (3) has been reached", ex.Message); - } + // A second completion attempt must not replace the original result. + var second = JsonSerializer.SerializeToElement("second", McpJsonUtilities.DefaultOptions); + await store.SetCompletedAsync(created.TaskId, second, CT); - [Fact] - public async Task CreateTaskAsync_EnforcesMaxTasksPerSessionLimit() - { - // Arrange - using var store = new InMemoryMcpTaskStore(maxTasksPerSession: 2); - var metadata = new McpTaskMetadata(); - - // Act - Create up to the limit for session-1 - await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, "session-1", TestContext.Current.CancellationToken); - await store.CreateTaskAsync(metadata, new RequestId("req-2"), new JsonRpcRequest { Method = "test" }, "session-1", TestContext.Current.CancellationToken); - - // Assert - Third task for session-1 should throw - var ex = await Assert.ThrowsAsync(() => - store.CreateTaskAsync(metadata, new RequestId("req-3"), new JsonRpcRequest { Method = "test" }, "session-1", TestContext.Current.CancellationToken)); - Assert.Contains("Maximum number of tasks per session (2) has been reached", ex.Message); - Assert.Contains("session-1", ex.Message); + var task = await store.GetTaskAsync(created.TaskId, CT); + Assert.NotNull(task); + Assert.Equal(McpTaskStatus.Completed, task.Status); + Assert.Equal("first", task.Result!.Value.GetString()); } [Fact] - public async Task CreateTaskAsync_MaxTasksPerSession_AllowsDifferentSessions() + public async Task ResolveInputRequestsAsync_OnTerminalTask_DoesNotResurrect() { - // Arrange - using var store = new InMemoryMcpTaskStore(maxTasksPerSession: 2); - var metadata = new McpTaskMetadata(); + var store = new InMemoryMcpTaskStore(); + var created = await store.CreateTaskAsync(CT); - // Act - Create 2 tasks for session-1 - await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, "session-1", TestContext.Current.CancellationToken); - await store.CreateTaskAsync(metadata, new RequestId("req-2"), new JsonRpcRequest { Method = "test" }, "session-1", TestContext.Current.CancellationToken); + await store.SetCompletedAsync( + created.TaskId, + JsonSerializer.SerializeToElement("done", McpJsonUtilities.DefaultOptions), + CT); - // Should still be able to create tasks for session-2 - var task3 = await store.CreateTaskAsync(metadata, new RequestId("req-3"), new JsonRpcRequest { Method = "test" }, "session-2", TestContext.Current.CancellationToken); - var task4 = await store.CreateTaskAsync(metadata, new RequestId("req-4"), new JsonRpcRequest { Method = "test" }, "session-2", TestContext.Current.CancellationToken); + // A client tasks/update against a Completed task must not flip it back to Working. + await store.ResolveInputRequestsAsync(created.TaskId, new Dictionary + { + ["req1"] = MakeResponse("response"), + }, CT); - // Assert - Assert.NotNull(task3); - Assert.NotNull(task4); + var task = await store.GetTaskAsync(created.TaskId, CT); + Assert.NotNull(task); + Assert.Equal(McpTaskStatus.Completed, task.Status); } [Fact] - public async Task CreateTaskAsync_MaxTasksPerSession_DoesNotApplyToNullSession() + public async Task ResolveInputRequestsAsync_OnTerminalTask_DoesNotFireEvent() { - // Arrange - using var store = new InMemoryMcpTaskStore(maxTasksPerSession: 1); - var metadata = new McpTaskMetadata(); - - // Act - Create multiple tasks with null session (should not be limited) - var task1 = await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - var task2 = await store.CreateTaskAsync(metadata, new RequestId("req-2"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - var task3 = await store.CreateTaskAsync(metadata, new RequestId("req-3"), new JsonRpcRequest { Method = "test" }, null, TestContext.Current.CancellationToken); - - // Assert - Assert.NotNull(task1); - Assert.NotNull(task2); - Assert.NotNull(task3); - } + var store = new InMemoryMcpTaskStore(); + var created = await store.CreateTaskAsync(CT); - [Fact] - public async Task CreateTaskAsync_CombinesMaxTasksAndMaxTasksPerSession() - { - // Arrange - Global limit of 5, per-session limit of 2 - using var store = new InMemoryMcpTaskStore(maxTasks: 5, maxTasksPerSession: 2); - var metadata = new McpTaskMetadata(); - - // Create 2 tasks for session-1 (hits per-session limit) - await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, "session-1", TestContext.Current.CancellationToken); - await store.CreateTaskAsync(metadata, new RequestId("req-2"), new JsonRpcRequest { Method = "test" }, "session-1", TestContext.Current.CancellationToken); - - // session-1 is at its limit - await Assert.ThrowsAsync(() => - store.CreateTaskAsync(metadata, new RequestId("req-3"), new JsonRpcRequest { Method = "test" }, "session-1", TestContext.Current.CancellationToken)); - - // But session-2 can still create tasks - await store.CreateTaskAsync(metadata, new RequestId("req-4"), new JsonRpcRequest { Method = "test" }, "session-2", TestContext.Current.CancellationToken); - await store.CreateTaskAsync(metadata, new RequestId("req-5"), new JsonRpcRequest { Method = "test" }, "session-2", TestContext.Current.CancellationToken); - - // Now global limit is reached (4 tasks total, but 5th would be 5) - // Wait, we have 4 tasks, should be able to create one more - await store.CreateTaskAsync(metadata, new RequestId("req-6"), new JsonRpcRequest { Method = "test" }, "session-3", TestContext.Current.CancellationToken); - - // Now at 5 tasks (global limit), should throw - var ex = await Assert.ThrowsAsync(() => - store.CreateTaskAsync(metadata, new RequestId("req-7"), new JsonRpcRequest { Method = "test" }, "session-3", TestContext.Current.CancellationToken)); - Assert.Contains("Maximum number of tasks (5) has been reached", ex.Message); - } + await store.SetCancelledAsync(created.TaskId, CT); - [Fact] - public async Task CreateTaskAsync_MaxTasksPerSession_ExcludesExpiredTasks() - { - // Arrange - Use FakeTimeProvider for deterministic testing - var fakeTime = new FakeTimeProvider(DateTimeOffset.UtcNow); - var shortTtl = TimeSpan.FromMilliseconds(50); - using var store = new TestInMemoryMcpTaskStore( - defaultTtl: shortTtl, - maxTtl: null, - pollInterval: null, - cleanupInterval: Timeout.InfiniteTimeSpan, - pageSize: 100, - maxTasks: null, - maxTasksPerSession: 1, - timeProvider: fakeTime); - - var metadata = new McpTaskMetadata(); - - // Create first task - await store.CreateTaskAsync(metadata, new RequestId("req-1"), new JsonRpcRequest { Method = "test" }, "session-1", TestContext.Current.CancellationToken); - - // Advance time past TTL to make the first task expire - fakeTime.Advance(shortTtl + TimeSpan.FromMilliseconds(1)); - - // Should be able to create another task since the first one expired - var task2 = await store.CreateTaskAsync(metadata, new RequestId("req-2"), new JsonRpcRequest { Method = "test" }, "session-1", TestContext.Current.CancellationToken); - - // Assert - Assert.NotNull(task2); - } + int eventCount = 0; + store.InputResponseReceived += _ => Interlocked.Increment(ref eventCount); - [Fact] - public async Task ListTasksAsync_KeysetPaginationWorksWithIdenticalTimestamps() - { - // Arrange - Use a fake time provider to create tasks with identical timestamps - var fakeTime = new FakeTimeProvider(DateTimeOffset.UtcNow); - using var store = new TestInMemoryMcpTaskStore( - defaultTtl: null, - maxTtl: null, - pollInterval: null, - cleanupInterval: Timeout.InfiniteTimeSpan, - pageSize: 5, - maxTasks: null, - maxTasksPerSession: null, - timeProvider: fakeTime); - - // Create 10 tasks - all with the EXACT same timestamp - var createdTasks = new List(); - for (int i = 0; i < 10; i++) + await store.ResolveInputRequestsAsync(created.TaskId, new Dictionary { - var task = await store.CreateTaskAsync( - new McpTaskMetadata(), - new RequestId($"req-{i}"), - new JsonRpcRequest { Method = "test" }, - null, - TestContext.Current.CancellationToken); - createdTasks.Add(task); - } - - // Verify all tasks have the same CreatedAt timestamp - var firstTimestamp = createdTasks[0].CreatedAt; - Assert.All(createdTasks, task => Assert.Equal(firstTimestamp, task.CreatedAt)); - - // Act - Get first page - var result1 = await store.ListTasksAsync(cancellationToken: TestContext.Current.CancellationToken); - - // Assert - First page should have 5 tasks - Assert.Equal(5, result1.Tasks.Count); - Assert.NotNull(result1.NextCursor); - - // Get second page using cursor - var result2 = await store.ListTasksAsync(cursor: result1.NextCursor, cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Second page should have 5 tasks - Assert.Equal(5, result2.Tasks.Count); - Assert.Null(result2.NextCursor); // No more pages - - // Verify no overlap between pages - var page1Ids = result1.Tasks.Select(t => t.TaskId).ToHashSet(); - var page2Ids = result2.Tasks.Select(t => t.TaskId).ToHashSet(); - Assert.Empty(page1Ids.Intersect(page2Ids)); - - // Verify we got all 10 tasks exactly once - var allReturnedIds = page1Ids.Union(page2Ids).ToHashSet(); - var allCreatedIds = createdTasks.Select(t => t.TaskId).ToHashSet(); - Assert.Equal(allCreatedIds, allReturnedIds); + ["req1"] = MakeResponse("response"), + }, CT); + + Assert.Equal(0, eventCount); } [Fact] - public async Task ListTasksAsync_TasksCreatedAfterFirstPageWithSameTimestampAppearInSecondPage() + public async Task SetInputRequestsAsync_OnTerminalTask_NoOps() { - // Arrange - Use a fake time provider so we can control timestamps precisely - var fakeTime = new FakeTimeProvider(DateTimeOffset.UtcNow); - using var store = new TestInMemoryMcpTaskStore( - defaultTtl: null, - maxTtl: null, - pollInterval: null, - cleanupInterval: Timeout.InfiniteTimeSpan, - pageSize: 5, - maxTasks: null, - maxTasksPerSession: null, - timeProvider: fakeTime); - - // Create initial 6 tasks - all with the same timestamp - // (6 so that first page has 5 and cursor points to task 5) - var initialTasks = new List(); - for (int i = 0; i < 6; i++) - { - var task = await store.CreateTaskAsync( - new McpTaskMetadata(), - new RequestId($"req-initial-{i}"), - new JsonRpcRequest { Method = "test" }, - null, - TestContext.Current.CancellationToken); - initialTasks.Add(task); - } - - // Get first page - should have 5 tasks with a cursor - var result1 = await store.ListTasksAsync(cancellationToken: TestContext.Current.CancellationToken); - Assert.Equal(5, result1.Tasks.Count); - Assert.NotNull(result1.NextCursor); - - // Now create 5 more tasks AFTER we got the first page cursor - // These tasks have the SAME timestamp as the cursor (time hasn't moved) - // Due to monotonic UUID v7 with counter, they should sort AFTER the cursor - var laterTasks = new List(); - for (int i = 0; i < 5; i++) - { - var task = await store.CreateTaskAsync( - new McpTaskMetadata(), - new RequestId($"req-later-{i}"), - new JsonRpcRequest { Method = "test" }, - null, - TestContext.Current.CancellationToken); - laterTasks.Add(task); - } - - // Verify all tasks have the same timestamp - var allTasks = initialTasks.Concat(laterTasks).ToList(); - var firstTimestamp = allTasks[0].CreatedAt; - Assert.All(allTasks, task => Assert.Equal(firstTimestamp, task.CreatedAt)); - - // Get ALL remaining pages - var allSubsequentTasks = new List(); - string? cursor = result1.NextCursor; - while (cursor != null) + var store = new InMemoryMcpTaskStore(); + var created = await store.CreateTaskAsync(CT); + + await store.SetCancelledAsync(created.TaskId, CT); + + await store.SetInputRequestsAsync(created.TaskId, new Dictionary { - var result = await store.ListTasksAsync(cursor: cursor, cancellationToken: TestContext.Current.CancellationToken); - allSubsequentTasks.AddRange(result.Tasks); - cursor = result.NextCursor; - } - - // Verify no overlap between first page and subsequent - var page1Ids = result1.Tasks.Select(t => t.TaskId).ToHashSet(); - var subsequentIds = allSubsequentTasks.Select(t => t.TaskId).ToHashSet(); - Assert.Empty(page1Ids.Intersect(subsequentIds)); - - // Verify we got all tasks - var allReturnedIds = page1Ids.Union(subsequentIds).ToHashSet(); - var allCreatedIds = allTasks.Select(t => t.TaskId).ToHashSet(); - Assert.Equal(allCreatedIds, allReturnedIds); - - // Most importantly: verify ALL the later tasks (created after first page) are surfaced - // in the subsequent pages - var laterTaskIds = laterTasks.Select(t => t.TaskId).ToHashSet(); - Assert.Superset(laterTaskIds, subsequentIds); + ["req1"] = MakeRequest("payload"), + }, CT); + + var task = await store.GetTaskAsync(created.TaskId, CT); + Assert.NotNull(task); + Assert.Equal(McpTaskStatus.Cancelled, task.Status); + Assert.True(task.InputRequests is null || task.InputRequests.Count == 0); } } diff --git a/tests/ModelContextProtocol.Tests/Server/July2026ProtocolBackcompatTests.cs b/tests/ModelContextProtocol.Tests/Server/July2026ProtocolBackcompatTests.cs new file mode 100644 index 000000000..4d78d9435 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/July2026ProtocolBackcompatTests.cs @@ -0,0 +1,151 @@ +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; + +namespace ModelContextProtocol.Tests.Server; + +/// +/// Verifies that the server-to-client request methods (, +/// , +/// ) keep working when the negotiated protocol revision is +/// 2026-07-28 on a stateful transport - for example, stdio. +/// +/// +/// Under 2026-07-28 the spec removes the corresponding server-to-client request methods, but +/// the SDK only fails fast in stateless mode (where the existing ThrowIf*Unsupported guards already +/// throw "X is not supported in stateless mode" because is +/// ). Stdio is implicitly stateful - one per process - so the +/// legacy elicitation/create / sampling/createMessage / roots/list flow still works. +/// Starting with 2026-07-28, Streamable HTTP servers are stateless by default, so those configurations +/// throw through the existing stateless guard unless the author explicitly opts back into sessions. +/// +public sealed class July2026ProtocolBackcompatTests : ClientServerTestBase +{ + public July2026ProtocolBackcompatTests(ITestOutputHelper testOutputHelper) + : base(testOutputHelper, startServer: false) + { + } + + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + services.Configure(options => + { + options.ProtocolVersion = "2026-07-28"; + }); + + mcpServerBuilder.WithTools([ + McpServerTool.Create(ElicitToolAsync, new() { Name = "elicit-tool" }), + McpServerTool.Create(SampleToolAsync, new() { Name = "sample-tool" }), + McpServerTool.Create(RootsToolAsync, new() { Name = "roots-tool" }), + ]); + } + + [Fact] + public async Task ElicitAsync_OnStatefulTransport_ResolvesViaLegacyRequest() + { + StartServer(); + await using var client = await CreateMcpClientForServer(new McpClientOptions + { + ProtocolVersion = "2026-07-28", + Capabilities = new ClientCapabilities + { + Elicitation = new ElicitationCapability(), + }, + Handlers = new McpClientHandlers + { + ElicitationHandler = (_, _) => new ValueTask(new ElicitResult { Action = "accept" }), + }, + }); + + var result = await client.CallToolAsync("elicit-tool", cancellationToken: TestContext.Current.CancellationToken); + + Assert.Equal("elicit-ok:accept", Assert.IsType(result.Content[0]).Text); + } + + [Fact] + public async Task SampleAsync_OnStatefulTransport_ResolvesViaLegacyRequest() + { + StartServer(); + await using var client = await CreateMcpClientForServer(new McpClientOptions + { + ProtocolVersion = "2026-07-28", + Capabilities = new ClientCapabilities + { + Sampling = new SamplingCapability(), + }, + Handlers = new McpClientHandlers + { + SamplingHandler = (_, _, _) => new ValueTask(new CreateMessageResult + { + Model = "test-model", + Role = Role.Assistant, + Content = [new TextContentBlock { Text = "hello back" }], + }), + }, + }); + + var result = await client.CallToolAsync("sample-tool", cancellationToken: TestContext.Current.CancellationToken); + + Assert.Equal("sample-ok:hello back", Assert.IsType(result.Content[0]).Text); + } + + [Fact] + public async Task RequestRootsAsync_OnStatefulTransport_ResolvesViaLegacyRequest() + { + StartServer(); + await using var client = await CreateMcpClientForServer(new McpClientOptions + { + ProtocolVersion = "2026-07-28", + Capabilities = new ClientCapabilities + { + Roots = new RootsCapability(), + }, + Handlers = new McpClientHandlers + { + RootsHandler = (_, _) => new ValueTask(new ListRootsResult + { + Roots = [new Root { Uri = "file:///home", Name = "home" }], + }), + }, + }); + + var result = await client.CallToolAsync("roots-tool", cancellationToken: TestContext.Current.CancellationToken); + + Assert.Equal("roots-ok:file:///home", Assert.IsType(result.Content[0]).Text); + } + + private static async Task ElicitToolAsync(McpServer server, CancellationToken cancellationToken) + { + var elicit = await server.ElicitAsync(new ElicitRequestParams + { + Message = "Need input", + RequestedSchema = new(), + }, cancellationToken); + return $"elicit-ok:{elicit.Action}"; + } + + private static async Task SampleToolAsync(McpServer server, CancellationToken cancellationToken) + { + var sample = await server.SampleAsync(new CreateMessageRequestParams + { + Messages = + [ + new SamplingMessage + { + Role = Role.User, + Content = [new TextContentBlock { Text = "ping" }], + }, + ], + MaxTokens = 16, + }, cancellationToken); + var text = sample.Content.OfType().FirstOrDefault()?.Text; + return $"sample-ok:{text}"; + } + + private static async Task RootsToolAsync(McpServer server, CancellationToken cancellationToken) + { + var roots = await server.RequestRootsAsync(new ListRootsRequestParams(), cancellationToken); + return $"roots-ok:{roots.Roots.FirstOrDefault()?.Uri}"; + } +} diff --git a/tests/ModelContextProtocol.Tests/Server/McpAppsIntegrationTests.cs b/tests/ModelContextProtocol.Tests/Server/McpAppsIntegrationTests.cs new file mode 100644 index 000000000..aadb6699d --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/McpAppsIntegrationTests.cs @@ -0,0 +1,100 @@ +#pragma warning disable MCPEXP003 + +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.Client; +using ModelContextProtocol.Extensions.Apps; +using ModelContextProtocol.Server; +using System.ComponentModel; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.Tests.Server; + +/// +/// Round-trip integration tests for the MCP Apps _meta.ui metadata: tools registered +/// with and processed by WithMcpApps() are listed through +/// and the structured _meta.ui object is verified +/// after serializing across the client-server transport. +/// +public class McpAppsIntegrationTests : ClientServerTestBase +{ + public McpAppsIntegrationTests(ITestOutputHelper testOutputHelper) + : base(testOutputHelper) + { + } + + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + mcpServerBuilder + .WithTools() + .WithMcpApps(); + } + + [Fact] + public async Task ListToolsAsync_RoundTripsMetaUi_ForToolWithAppUiAttribute() + { + await using McpClient client = await CreateMcpClientForServer(); + + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + var weatherTool = Assert.Single(tools, t => t.Name == "weather_tool"); + + JsonObject? uiNode = weatherTool.ProtocolTool.Meta?["ui"]?.AsObject(); + Assert.NotNull(uiNode); + Assert.Equal("ui://weather/view.html", uiNode["resourceUri"]?.GetValue()); + + // Visibility was not restricted, so the property must be absent entirely + // (not merely serialized as null). + Assert.False(uiNode.ContainsKey("visibility")); + } + + [Fact] + public async Task ListToolsAsync_RoundTripsMetaUiVisibility_ForRestrictedTool() + { + await using McpClient client = await CreateMcpClientForServer(); + + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + var modelOnlyTool = Assert.Single(tools, t => t.Name == "model_only_tool"); + + JsonObject? uiNode = modelOnlyTool.ProtocolTool.Meta?["ui"]?.AsObject(); + Assert.NotNull(uiNode); + Assert.Equal("ui://model-only/view.html", uiNode["resourceUri"]?.GetValue()); + + JsonArray? visibility = uiNode["visibility"]?.AsArray(); + Assert.NotNull(visibility); + JsonNode? single = Assert.Single(visibility); + Assert.Equal(McpUiToolVisibility.Model, single?.GetValue()); + } + + [Fact] + public async Task ListToolsAsync_HasNoUiMeta_ForToolWithoutAppUiAttribute() + { + await using McpClient client = await CreateMcpClientForServer(); + + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + var plainTool = Assert.Single(tools, t => t.Name == "plain_tool"); + + // The tool must carry no "ui" metadata at all: either no _meta object, + // or a _meta without the "ui" key (not a "ui": null entry). + JsonObject? meta = plainTool.ProtocolTool.Meta; + Assert.False(meta is not null && meta.ContainsKey("ui")); + } + + public sealed class AppUiTools + { + [McpServerTool(Name = "weather_tool")] + [McpAppUi(ResourceUri = "ui://weather/view.html")] + [Description("Get weather")] + public static string WeatherTool(string location) => $"Weather for {location}"; + + [McpServerTool(Name = "model_only_tool")] + [McpAppUi(ResourceUri = "ui://model-only/view.html", Visibility = [McpUiToolVisibility.Model])] + [Description("Model only")] + public static string ModelOnlyTool(string location) => $"Model only for {location}"; + + [McpServerTool(Name = "plain_tool")] + [Description("Plain tool without app UI")] + public static string PlainTool(string input) => input; + } +} diff --git a/tests/ModelContextProtocol.Tests/Server/McpAppsTests.cs b/tests/ModelContextProtocol.Tests/Server/McpAppsTests.cs new file mode 100644 index 000000000..756417de0 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/McpAppsTests.cs @@ -0,0 +1,489 @@ +#pragma warning disable MCPEXP003 + +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Options; +using ModelContextProtocol.Extensions.Apps; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.ComponentModel; +using System.Text.Json; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.Tests.Server; + +/// +/// Tests for MCP Apps extension support: McpApps constants, typed metadata models, +/// McpAppUiAttribute, SetAppUi, and ApplyAppUiAttributes. +/// +public class McpAppsTests +{ + #region F1: Constants + + [Fact] + public void McpApps_Constants_HaveExpectedValues() + { + Assert.Equal("text/html;profile=mcp-app", McpApps.HtmlMimeType); + Assert.Equal("io.modelcontextprotocol/ui", McpApps.ExtensionId); + } + + [Fact] + public void McpUiToolVisibility_Constants_HaveExpectedValues() + { + Assert.Equal("model", McpUiToolVisibility.Model); + Assert.Equal("app", McpUiToolVisibility.App); + } + + #endregion + + #region F2: Typed Metadata Models + + [Fact] + public void McpUiToolMeta_DefaultsToNull() + { + var meta = new McpUiToolMeta(); + Assert.Null(meta.ResourceUri); + Assert.Null(meta.Visibility); + } + + [Fact] + public void McpUiToolMeta_CanBeRoundtrippedAsJson() + { + var meta = new McpUiToolMeta + { + ResourceUri = "ui://weather/view.html", + Visibility = [McpUiToolVisibility.Model, McpUiToolVisibility.App], + }; + + var json = JsonSerializer.Serialize(meta, McpApps.SerializerOptions); + var deserialized = JsonSerializer.Deserialize(json, McpApps.SerializerOptions); + + Assert.NotNull(deserialized); + Assert.Equal("ui://weather/view.html", deserialized.ResourceUri); + Assert.Equal(["model", "app"], deserialized.Visibility); + } + + [Fact] + public void McpUiToolMeta_OmitsNullProperties() + { + var meta = new McpUiToolMeta { ResourceUri = "ui://app" }; + var json = JsonSerializer.Serialize(meta, McpApps.SerializerOptions); + var doc = JsonDocument.Parse(json); + + Assert.True(doc.RootElement.TryGetProperty("resourceUri", out _)); + Assert.False(doc.RootElement.TryGetProperty("visibility", out _)); + } + + [Fact] + public void McpUiResourceMeta_CanBeRoundtrippedAsJson() + { + var meta = new McpUiResourceMeta + { + Domain = "https://app.example.com", + PrefersBorder = true, + Csp = new McpUiResourceCsp + { + ConnectDomains = ["https://api.example.com"], + ResourceDomains = ["https://cdn.example.com"], + FrameDomains = ["https://embed.example.com"], + BaseUris = ["https://app.example.com"], + }, + Permissions = new McpUiResourcePermissions + { + Allow = ["camera", "microphone"], + }, + }; + + var json = JsonSerializer.Serialize(meta, McpApps.SerializerOptions); + var deserialized = JsonSerializer.Deserialize(json, McpApps.SerializerOptions); + + Assert.NotNull(deserialized); + Assert.Equal("https://app.example.com", deserialized.Domain); + Assert.True(deserialized.PrefersBorder); + Assert.NotNull(deserialized.Csp); + Assert.Equal(["https://api.example.com"], deserialized.Csp.ConnectDomains); + Assert.Equal(["https://cdn.example.com"], deserialized.Csp.ResourceDomains); + Assert.Equal(["https://embed.example.com"], deserialized.Csp.FrameDomains); + Assert.Equal(["https://app.example.com"], deserialized.Csp.BaseUris); + Assert.NotNull(deserialized.Permissions); + Assert.Equal(["camera", "microphone"], deserialized.Permissions.Allow); + } + + [Fact] + public void McpUiClientCapabilities_CanBeRoundtrippedAsJson() + { + var caps = new McpUiClientCapabilities + { + MimeTypes = [McpApps.HtmlMimeType], + }; + + var json = JsonSerializer.Serialize(caps, McpApps.SerializerOptions); + var deserialized = JsonSerializer.Deserialize(json, McpApps.SerializerOptions); + + Assert.NotNull(deserialized); + Assert.Equal([McpApps.HtmlMimeType], deserialized.MimeTypes); + } + + #endregion + + #region F3: GetUiCapability + + [Fact] + public void GetUiCapability_ReturnsNull_WhenCapabilitiesIsNull() + { + Assert.Null(McpApps.GetUiCapability(null)); + } + + [Fact] + public void GetUiCapability_ReturnsNull_WhenExtensionsIsNull() + { + var caps = new ClientCapabilities(); + Assert.Null(McpApps.GetUiCapability(caps)); + } + + [Fact] + public void GetUiCapability_ReturnsNull_WhenExtensionKeyIsMissing() + { +#pragma warning disable MCPEXP001 + var caps = new ClientCapabilities + { + Extensions = new Dictionary + { + ["other.extension"] = new { }, + } + }; +#pragma warning restore MCPEXP001 + Assert.Null(McpApps.GetUiCapability(caps)); + } + + [Fact] + public void GetUiCapability_ReturnsCapabilities_WhenExtensionIsPresent() + { + // Simulate what the SDK does when deserializing ClientCapabilities from JSON: + // extensions values come in as JsonElement. + var json = $$""" + { + "extensions": { + "{{McpApps.ExtensionId}}": { + "mimeTypes": ["{{McpApps.HtmlMimeType}}"] + } + } + } + """; + + var caps = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); + Assert.NotNull(caps); + + var uiCaps = McpApps.GetUiCapability(caps); + + Assert.NotNull(uiCaps); + Assert.Equal([McpApps.HtmlMimeType], uiCaps.MimeTypes); + } + + [Fact] + public void GetUiCapability_ReturnsNull_WhenExtensionValueIsNull() + { + var json = $$""" + { + "extensions": { + "{{McpApps.ExtensionId}}": null + } + } + """; + + var caps = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); + Assert.NotNull(caps); + + Assert.Null(McpApps.GetUiCapability(caps)); + } + + [Theory] + [InlineData("\"a string value\"")] + [InlineData("42")] + [InlineData("true")] + [InlineData("[1, 2, 3]")] + public void GetUiCapability_ReturnsNull_WhenExtensionValueIsMalformed(string malformedValue) + { + var json = $$""" + { + "extensions": { + "{{McpApps.ExtensionId}}": {{malformedValue}} + } + } + """; + + var caps = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); + Assert.NotNull(caps); + + // Should return null gracefully, not throw + Assert.Null(McpApps.GetUiCapability(caps)); + } + + [Fact] + public void GetUiCapability_ReturnsCapabilities_WhenValueIsStronglyTyped() + { +#pragma warning disable MCPEXP001 + var caps = new ClientCapabilities + { + Extensions = new Dictionary + { + [McpApps.ExtensionId] = new McpUiClientCapabilities + { + MimeTypes = [McpApps.HtmlMimeType], + }, + } + }; +#pragma warning restore MCPEXP001 + + var uiCaps = McpApps.GetUiCapability(caps); + Assert.NotNull(uiCaps); + Assert.Equal([McpApps.HtmlMimeType], uiCaps.MimeTypes); + } + + #endregion + + #region F6: McpAppUiAttribute via ApplyAppUiAttributes + + [Fact] + public void ApplyAppUiAttributes_PopulatesUiObject() + { + var method = typeof(TestToolsWithAppUi).GetMethod(nameof(TestToolsWithAppUi.WeatherTool))!; + var tool = McpServerTool.Create(method, target: null); + + McpApps.ApplyAppUiAttributes(tool); + + var meta = tool.ProtocolTool.Meta; + Assert.NotNull(meta); + + // Structured "ui" object + var uiNode = meta["ui"]?.AsObject(); + Assert.NotNull(uiNode); + Assert.Equal("ui://weather/view.html", uiNode["resourceUri"]?.GetValue()); + } + + [Fact] + public void ApplyAppUiAttributes_WithVisibility_IncludesVisibilityInUiObject() + { + var method = typeof(TestToolsWithAppUi).GetMethod(nameof(TestToolsWithAppUi.ModelOnlyTool))!; + var tool = McpServerTool.Create(method, target: null); + + McpApps.ApplyAppUiAttributes(tool); + + var uiNode = tool.ProtocolTool.Meta?["ui"]?.AsObject(); + Assert.NotNull(uiNode); + Assert.Equal("ui://model-only/view.html", uiNode["resourceUri"]?.GetValue()); + + var visibility = uiNode["visibility"]?.AsArray(); + Assert.NotNull(visibility); + Assert.Single(visibility); + Assert.Equal(McpUiToolVisibility.Model, visibility[0]?.GetValue()); + } + + [Fact] + public void ApplyAppUiAttributes_ExplicitMeta_TakesPrecedence() + { + // Explicit Meta["ui"] in options should override the attribute + var method = typeof(TestToolsWithAppUi).GetMethod(nameof(TestToolsWithAppUi.WeatherTool))!; + var explicitMeta = new JsonObject + { + ["ui"] = new JsonObject { ["resourceUri"] = "ui://explicit/override.html" }, + }; + + var tool = McpServerTool.Create(method, target: null, new McpServerToolCreateOptions { Meta = explicitMeta }); + + McpApps.ApplyAppUiAttributes(tool); + + var uiNode = tool.ProtocolTool.Meta?["ui"]?.AsObject(); + // Explicit Meta["ui"] wins — ApplyAppUiAttributes does not overwrite + Assert.Equal("ui://explicit/override.html", uiNode?["resourceUri"]?.GetValue()); + } + + [Fact] + public void ApplyAppUiAttributes_Collection_ProcessesAllTools() + { + var tools = new[] + { + McpServerTool.Create(typeof(TestToolsWithAppUi).GetMethod(nameof(TestToolsWithAppUi.WeatherTool))!, target: null), + McpServerTool.Create(typeof(TestToolsWithAppUi).GetMethod(nameof(TestToolsWithAppUi.ModelOnlyTool))!, target: null), + }; + + McpApps.ApplyAppUiAttributes(tools); + + Assert.NotNull(tools[0].ProtocolTool.Meta?["ui"]); + Assert.NotNull(tools[1].ProtocolTool.Meta?["ui"]); + } + + [Fact] + public void ApplyAppUiAttributes_NoAttribute_DoesNothing() + { + var tool = McpServerTool.Create( + (string input) => input, + new McpServerToolCreateOptions { Name = "plain_tool" }); + + McpApps.ApplyAppUiAttributes(tool); + + Assert.Null(tool.ProtocolTool.Meta); + } + + #endregion + + #region F7: SetAppUi + + [Fact] + public void SetAppUi_PopulatesUiObject() + { + var tool = McpServerTool.Create( + (string location) => $"Weather for {location}", + new McpServerToolCreateOptions { Name = "get_weather" }); + + McpApps.SetAppUi(tool, new McpUiToolMeta { ResourceUri = "ui://weather/view.html" }); + + var meta = tool.ProtocolTool.Meta; + Assert.NotNull(meta); + + var uiNode = meta["ui"]?.AsObject(); + Assert.NotNull(uiNode); + Assert.Equal("ui://weather/view.html", uiNode["resourceUri"]?.GetValue()); + } + + [Fact] + public void SetAppUi_WithVisibility_IncludesVisibilityInUiObject() + { + var tool = McpServerTool.Create( + (string location) => $"Weather for {location}", + new McpServerToolCreateOptions { Name = "get_weather" }); + + McpApps.SetAppUi(tool, new McpUiToolMeta + { + ResourceUri = "ui://weather/view.html", + Visibility = [McpUiToolVisibility.Model], + }); + + var uiNode = tool.ProtocolTool.Meta?["ui"]?.AsObject(); + Assert.NotNull(uiNode); + + var visibility = uiNode["visibility"]?.AsArray(); + Assert.NotNull(visibility); + Assert.Single(visibility); + Assert.Equal(McpUiToolVisibility.Model, visibility[0]?.GetValue()); + } + + [Fact] + public void SetAppUi_DoesNotOverwrite_ExistingUiKey() + { + var tool = McpServerTool.Create( + (string location) => $"Weather for {location}", + new McpServerToolCreateOptions + { + Name = "get_weather", + Meta = new JsonObject + { + ["ui"] = new JsonObject { ["resourceUri"] = "ui://explicit/view.html" }, + }, + }); + + McpApps.SetAppUi(tool, new McpUiToolMeta { ResourceUri = "ui://new/view.html" }); + + // Existing Meta["ui"] is preserved + var uiNode = tool.ProtocolTool.Meta?["ui"]?.AsObject(); + Assert.Equal("ui://explicit/view.html", uiNode?["resourceUri"]?.GetValue()); + } + + [Fact] + public void SetAppUi_NullResourceUri_ProducesUiObjectWithoutResourceUri() + { + var tool = McpServerTool.Create( + (string location) => $"Weather for {location}", + new McpServerToolCreateOptions { Name = "get_weather" }); + + McpApps.SetAppUi(tool, new McpUiToolMeta { Visibility = [McpUiToolVisibility.App] }); + + var uiNode = tool.ProtocolTool.Meta?["ui"]?.AsObject(); + Assert.NotNull(uiNode); + Assert.Null(uiNode["resourceUri"]); + } + + [Fact] + public void SetAppUi_ReturnsSameTool() + { + var tool = McpServerTool.Create( + (string location) => $"Weather for {location}", + new McpServerToolCreateOptions { Name = "get_weather" }); + + var result = McpApps.SetAppUi(tool, new McpUiToolMeta { ResourceUri = "ui://weather/view.html" }); + Assert.Same(tool, result); + } + + #endregion + + #region Builder Extension: WithMcpApps + + [Fact] + public void WithMcpApps_AppliesAppUiAttributes_ViaOptions() + { + var sc = new ServiceCollection(); + sc.AddMcpServer() + .WithTools([typeof(TestToolsWithAppUi)]) + .WithMcpApps(); + + using var sp = sc.BuildServiceProvider(); + var options = sp.GetRequiredService>().Value; + + Assert.NotNull(options.ToolCollection); + Assert.NotEmpty(options.ToolCollection); + + // Both tools should have their [McpAppUi] attributes applied + var toolsWithUi = options.ToolCollection.Where(t => t.ProtocolTool.Meta?["ui"] is not null).ToList(); + Assert.Equal(2, toolsWithUi.Count); + + var weatherTool = toolsWithUi.First(t => t.ProtocolTool.Meta!["ui"]!["resourceUri"]?.GetValue() == "ui://weather/view.html"); + Assert.NotNull(weatherTool); + } + + [Fact] + public void WithMcpApps_EmptyToolCollection_DoesNotThrow() + { + var sc = new ServiceCollection(); + sc.AddMcpServer() + .WithMcpApps(); + + using var sp = sc.BuildServiceProvider(); + var options = sp.GetRequiredService>().Value; + + // Should be a no-op when no tools are registered + Assert.True(options.ToolCollection is null || options.ToolCollection.IsEmpty); + } + + [Fact] + public void WithMcpApps_AdvertisesServerCapability() + { + var sc = new ServiceCollection(); + sc.AddMcpServer() + .WithMcpApps(); + + using var sp = sc.BuildServiceProvider(); + var options = sp.GetRequiredService>().Value; + + Assert.NotNull(options.Capabilities); + Assert.NotNull(options.Capabilities.Extensions); + Assert.True(options.Capabilities.Extensions.ContainsKey(McpApps.ExtensionId)); + } + + #endregion + + #region Test helper types + + [McpServerToolType] + private static class TestToolsWithAppUi + { + [McpServerTool] + [McpAppUi(ResourceUri = "ui://weather/view.html")] + [Description("Get weather")] + public static string WeatherTool(string location) => $"Weather for {location}"; + + [McpServerTool] + [McpAppUi(ResourceUri = "ui://model-only/view.html", Visibility = [McpUiToolVisibility.Model])] + public static string ModelOnlyTool(string location) => $"Model only for {location}"; + } + + #endregion +} diff --git a/tests/ModelContextProtocol.Tests/Server/McpHeaderAttributeTests.cs b/tests/ModelContextProtocol.Tests/Server/McpHeaderAttributeTests.cs new file mode 100644 index 000000000..85374a589 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/McpHeaderAttributeTests.cs @@ -0,0 +1,79 @@ +using ModelContextProtocol.Server; + +namespace ModelContextProtocol.Tests.Server; + +public class McpHeaderAttributeTests +{ + [Theory] + [InlineData("Region")] + [InlineData("TenantId")] + [InlineData("Priority")] + [InlineData("X-Custom")] + [InlineData("x!header")] + [InlineData("x#header")] + [InlineData("x~header")] + public void Constructor_ValidHeaderName_Succeeds(string name) + { + var attr = new McpHeaderAttribute(name); + Assert.Equal(name, attr.Name); + } + + [Fact] + public void Constructor_NameWithSpace_Throws() + { + Assert.Throws(() => new McpHeaderAttribute("My Region")); + } + + [Fact] + public void Constructor_NameWithColon_Throws() + { + Assert.Throws(() => new McpHeaderAttribute("Region:Primary")); + } + + [Theory] + [InlineData("Region(1)")] + [InlineData("path/to")] + [InlineData("key=value")] + [InlineData("name@host")] + [InlineData("with,comma")] + [InlineData("with;semi")] + [InlineData("with[bracket")] + [InlineData("with{brace")] + [InlineData("with\"quote")] + [InlineData("with\\backslash")] + [InlineData("with?question")] + public void Constructor_NonTcharCharacter_Throws(string name) + { + Assert.Throws(() => new McpHeaderAttribute(name)); + } + + [Fact] + public void Constructor_NullName_Throws() + { + Assert.ThrowsAny(() => new McpHeaderAttribute(null!)); + } + + [Fact] + public void Constructor_EmptyName_Throws() + { + Assert.ThrowsAny(() => new McpHeaderAttribute("")); + } + + [Fact] + public void Constructor_WhitespaceName_Throws() + { + Assert.ThrowsAny(() => new McpHeaderAttribute(" ")); + } + + [Fact] + public void Constructor_NameWithControlCharacter_Throws() + { + Assert.Throws(() => new McpHeaderAttribute("Region\t1")); + } + + [Fact] + public void Constructor_NameWithNonAscii_Throws() + { + Assert.Throws(() => new McpHeaderAttribute("Région")); + } +} diff --git a/tests/ModelContextProtocol.Tests/Server/McpServerPrimitiveCollectionTests.cs b/tests/ModelContextProtocol.Tests/Server/McpServerPrimitiveCollectionTests.cs new file mode 100644 index 000000000..7acac660e --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/McpServerPrimitiveCollectionTests.cs @@ -0,0 +1,595 @@ +using Microsoft.Extensions.AI; +using ModelContextProtocol.Server; + +namespace ModelContextProtocol.Tests.Server; + +public class McpServerPrimitiveCollectionTests +{ + private static McpServerTool CreateTool(string name) => + McpServerTool.Create(() => name, new() { Name = name }); + + private static McpServerPrompt CreatePrompt(string name) => + McpServerPrompt.Create(() => new ChatMessage(ChatRole.User, name), new() { Name = name }); + + // ------------------------------------------------------------------------- + // Changed event without DeferChangedEvents + // ------------------------------------------------------------------------- + + [Fact] + public void TryAdd_NewTool_ReturnsTrue_FiresChanged() + { + var collection = new McpServerPrimitiveCollection(); + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + bool added = collection.TryAdd(CreateTool("tool1")); + + Assert.True(added); + Assert.Equal(1, changeCount); + } + + [Fact] + public void TryAdd_DuplicateName_ReturnsFalse_DoesNotFireChanged() + { + var collection = new McpServerPrimitiveCollection(); + collection.TryAdd(CreateTool("tool1")); + + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + bool added = collection.TryAdd(CreateTool("tool1")); + + Assert.False(added); + Assert.Equal(0, changeCount); + } + + [Fact] + public void TryAdd_SameTool_TwiceInSequence_FiresOnlyOnFirst() + { + var collection = new McpServerPrimitiveCollection(); + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + bool first = collection.TryAdd(CreateTool("tool1")); + bool second = collection.TryAdd(CreateTool("tool1")); + + Assert.True(first); + Assert.False(second); + Assert.Equal(1, changeCount); + } + + [Fact] + public void Remove_ExistingTool_ReturnsTrue_FiresChanged() + { + var tool = CreateTool("tool1"); + var collection = new McpServerPrimitiveCollection(); + collection.TryAdd(tool); + + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + bool removed = collection.Remove(tool); + + Assert.True(removed); + Assert.Equal(1, changeCount); + } + + [Fact] + public void Remove_NonExistentTool_ReturnsFalse_DoesNotFireChanged() + { + var collection = new McpServerPrimitiveCollection(); + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + bool removed = collection.Remove(CreateTool("tool1")); + + Assert.False(removed); + Assert.Equal(0, changeCount); + } + + [Fact] + public void Clear_NonEmptyCollection_FiresChanged() + { + var collection = new McpServerPrimitiveCollection(); + collection.TryAdd(CreateTool("tool1")); + collection.TryAdd(CreateTool("tool2")); + + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + collection.Clear(); + + Assert.Equal(1, changeCount); + Assert.Empty(collection); + } + + [Fact] + public void Clear_EmptyCollection_FiresChanged() + { + var collection = new McpServerPrimitiveCollection(); + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + collection.Clear(); + + Assert.Equal(1, changeCount); + } + + // ------------------------------------------------------------------------- + // DeferChangedEvents -- basic deferral behavior + // ------------------------------------------------------------------------- + + [Fact] + public void DeferChangedEvents_NoMutation_DoesNotFireChanged() + { + var collection = new McpServerPrimitiveCollection(); + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + using (collection.DeferChangedEvents()) + { + // no mutations + } + + Assert.Equal(0, changeCount); + } + + [Fact] + public void DeferChangedEvents_SingleMutation_FiresOneChanged() + { + var collection = new McpServerPrimitiveCollection(); + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + using (collection.DeferChangedEvents()) + { + collection.TryAdd(CreateTool("tool1")); + Assert.Equal(0, changeCount); // not fired yet + } + + Assert.Equal(1, changeCount); + } + + [Fact] + public void DeferChangedEvents_MultipleMutations_FiresOneChanged() + { + var collection = new McpServerPrimitiveCollection(); + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + using (collection.DeferChangedEvents()) + { + collection.TryAdd(CreateTool("tool1")); + collection.TryAdd(CreateTool("tool2")); + collection.TryAdd(CreateTool("tool3")); + Assert.Equal(0, changeCount); + } + + Assert.Equal(1, changeCount); + } + + [Fact] + public void DeferChangedEvents_MixedAddAndRemove_FiresOneChanged() + { + var tool = CreateTool("tool1"); + var collection = new McpServerPrimitiveCollection(); + collection.TryAdd(tool); + + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + using (collection.DeferChangedEvents()) + { + collection.TryAdd(CreateTool("tool2")); + collection.Remove(tool); + Assert.Equal(0, changeCount); + } + + Assert.Equal(1, changeCount); + } + + [Fact] + public void DeferChangedEvents_AddThenRemoveSameTool_FiresOneChanged() + { + // Net effect is no change in contents, but a Changed notification still fires + // because mutations occurred during the scope. + var collection = new McpServerPrimitiveCollection(); + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + using (collection.DeferChangedEvents()) + { + var tool = CreateTool("tool1"); + collection.TryAdd(tool); + collection.Remove(tool); + Assert.Equal(0, changeCount); + } + + Assert.Equal(1, changeCount); + Assert.Empty(collection); + } + + [Fact] + public void DeferChangedEvents_DuplicateTryAdd_OnlySuccessfulMutationMarksChange() + { + // The first TryAdd succeeds (mutation), the second fails (no mutation). + // Exactly one Changed fires on dispose. + var collection = new McpServerPrimitiveCollection(); + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + using (collection.DeferChangedEvents()) + { + collection.TryAdd(CreateTool("tool1")); // succeeds + collection.TryAdd(CreateTool("tool1")); // fails -- duplicate name + Assert.Equal(0, changeCount); + } + + Assert.Equal(1, changeCount); + } + + [Fact] + public void DeferChangedEvents_OnlyFailedTryAdds_DoesNotFireChanged() + { + var tool = CreateTool("tool1"); + var collection = new McpServerPrimitiveCollection(); + collection.TryAdd(tool); + + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + using (collection.DeferChangedEvents()) + { + collection.TryAdd(CreateTool("tool1")); // fails -- already present + Assert.Equal(0, changeCount); + } + + Assert.Equal(0, changeCount); + } + + [Fact] + public void DeferChangedEvents_WithClear_FiresOneChanged() + { + var collection = new McpServerPrimitiveCollection(); + collection.TryAdd(CreateTool("tool1")); + collection.TryAdd(CreateTool("tool2")); + + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + using (collection.DeferChangedEvents()) + { + collection.Clear(); + Assert.Equal(0, changeCount); + } + + Assert.Equal(1, changeCount); + } + + [Fact] + public void DeferChangedEvents_Nested_FiresOnceWhenAllScopesDisposed() + { + var collection = new McpServerPrimitiveCollection(); + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + using (collection.DeferChangedEvents()) + { + collection.TryAdd(CreateTool("tool1")); + + using (collection.DeferChangedEvents()) + { + collection.TryAdd(CreateTool("tool2")); + Assert.Equal(0, changeCount); + } + + Assert.Equal(0, changeCount); // inner scope disposed, but outer still active + collection.TryAdd(CreateTool("tool3")); + } + + Assert.Equal(1, changeCount); + } + + [Fact] + public void DeferChangedEvents_OutOfOrderDisposal_FiresOnceWhenAllScopesDisposed() + { + // Scopes created in order 1, 2 but disposed in reverse order 2, 1. + // Changed should NOT fire when scope 2 is disposed (scope 1 still active). + // Changed SHOULD fire when scope 1 is disposed (last active scope gone). + var collection = new McpServerPrimitiveCollection(); + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + var scope1 = collection.DeferChangedEvents(); + var scope2 = collection.DeferChangedEvents(); + collection.TryAdd(CreateTool("tool1")); + + Assert.Equal(0, changeCount); + scope2.Dispose(); // out-of-order dispose; scope1 still active + Assert.Equal(0, changeCount); + + scope1.Dispose(); // last scope disposed; Changed fires now + Assert.Equal(1, changeCount); + } + + [Fact] + public void DeferChangedEvents_DoubleDisposeSingleScope_DoesNotDecrementCountTwice() + { + // Double-disposing scope1 must not decrement _activeDeferralScopes more than once, + // which would cause Changed to fire while scope2 is still active. + var collection = new McpServerPrimitiveCollection(); + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + var scope1 = collection.DeferChangedEvents(); + var scope2 = collection.DeferChangedEvents(); + collection.TryAdd(CreateTool("tool1")); + + scope1.Dispose(); + Assert.Equal(0, changeCount); // scope2 still active + + scope1.Dispose(); // second dispose of scope1 -- must be a no-op + Assert.Equal(0, changeCount); // scope2 is still active; Changed must NOT fire yet + + scope2.Dispose(); // now all scopes are disposed; Changed fires + Assert.Equal(1, changeCount); + } + + [Fact] + public void DeferChangedEvents_OutOfOrderDisposalNoMutation_DoesNotFireChanged() + { + // Same out-of-order pattern but with no mutations -- verifies no spurious Changed. + var collection = new McpServerPrimitiveCollection(); + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + var scope1 = collection.DeferChangedEvents(); + var scope2 = collection.DeferChangedEvents(); + + scope2.Dispose(); + scope1.Dispose(); + + Assert.Equal(0, changeCount); + } + + [Fact] + public void DeferChangedEvents_AfterScope_ResumesImmediateNotifications() + { + var collection = new McpServerPrimitiveCollection(); + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + using (collection.DeferChangedEvents()) + { + collection.TryAdd(CreateTool("tool1")); + } + + Assert.Equal(1, changeCount); + + // After the scope, each mutation fires immediately + collection.TryAdd(CreateTool("tool2")); + Assert.Equal(2, changeCount); + + collection.TryAdd(CreateTool("tool3")); + Assert.Equal(3, changeCount); + } + + [Fact] + public void DeferChangedEvents_DisposeIdempotent_DoesNotFireTwice() + { + var collection = new McpServerPrimitiveCollection(); + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + var scope = collection.DeferChangedEvents(); + collection.TryAdd(CreateTool("tool1")); + + scope.Dispose(); + Assert.Equal(1, changeCount); + + scope.Dispose(); // second dispose should be a no-op + Assert.Equal(1, changeCount); + } + + [Fact] + public void DeferChangedEvents_ScopeWithNoHandlers_DoesNotThrow() + { + var collection = new McpServerPrimitiveCollection(); + // no Changed handler registered + + using (collection.DeferChangedEvents()) + { + collection.TryAdd(CreateTool("tool1")); + } + + Assert.Single(collection); + } + + [Fact] + public void WithoutDeferChangedEvents_EachMutationFiresImmediately() + { + var collection = new McpServerPrimitiveCollection(); + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + collection.TryAdd(CreateTool("tool1")); + Assert.Equal(1, changeCount); + + collection.TryAdd(CreateTool("tool2")); + Assert.Equal(2, changeCount); + + collection.TryAdd(CreateTool("tool3")); + Assert.Equal(3, changeCount); + } + + // ------------------------------------------------------------------------- + // DeferChangedEvents -- concurrency + // ------------------------------------------------------------------------- + + [Fact] + public async Task DeferChangedEvents_ConcurrentMutations_FiresExactlyOneChanged() + { + const int threadCount = 10; + var collection = new McpServerPrimitiveCollection(); + int changeCount = 0; + collection.Changed += (_, _) => Interlocked.Increment(ref changeCount); + + using (collection.DeferChangedEvents()) + { + await Task.WhenAll(Enumerable.Range(0, threadCount).Select(i => + Task.Run(() => collection.TryAdd(CreateTool($"tool{i}")), TestContext.Current.CancellationToken))); + } + + Assert.Equal(1, changeCount); + Assert.Equal(threadCount, collection.Count); + } + + [Fact] + public async Task DeferChangedEvents_MutationRacingWithDispose_NotificationNotLost() + { + // Run many iterations to reliably exercise the race between a mutation + // and disposal of the outermost scope. With the lock-free implementation + // the race could cause the notification to be lost; the lock-based + // implementation must always fire exactly one notification. + for (int iteration = 0; iteration < 200; iteration++) + { + var collection = new McpServerPrimitiveCollection(); + int changeCount = 0; + collection.Changed += (_, _) => Interlocked.Increment(ref changeCount); + + var scope = collection.DeferChangedEvents(); + + // Run the mutation and the dispose concurrently. + var addTask = Task.Run(() => collection.TryAdd(CreateTool("tool1")), TestContext.Current.CancellationToken); + var disposeTask = Task.Run(() => scope.Dispose(), TestContext.Current.CancellationToken); + + await Task.WhenAll(addTask, disposeTask); + + // Regardless of ordering: exactly one notification must have fired. + // - If TryAdd runs before Dispose: the mutation marks _pendingChange; + // Dispose sees depth -> 0 with a pending change and fires. + // - If Dispose runs before TryAdd: depth is already 0 when TryAdd + // calls RaiseChanged, so it fires immediately. + // The lock prevents the third (buggy) interleaving where Dispose + // sees no pending change and TryAdd sees depth > 0, dropping the event. + Assert.Equal(1, changeCount); + } + } + + // ------------------------------------------------------------------------- + // DeferChangedEvents -- derived-type coalescing + // ------------------------------------------------------------------------- + + private sealed class TrackingCollection : McpServerPrimitiveCollection + { + public void RaiseChangedDirectly() => RaiseChanged(); + } + + [Fact] + public void DeferChangedEvents_DerivedTypeCallsRaiseChanged_Coalesces() + { + // Verify that derived types calling RaiseChanged() directly (the path + // McpServerResourceCollection and other subclasses rely on) are gated + // by the same deferral check. + var collection = new TrackingCollection(); + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + using (collection.DeferChangedEvents()) + { + collection.RaiseChangedDirectly(); + collection.RaiseChangedDirectly(); + Assert.Equal(0, changeCount); + } + + Assert.Equal(1, changeCount); + } + + [Fact] + public void DeferChangedEvents_DerivedTypeRaisesChanged_OutsideScope_FiresImmediately() + { + var collection = new TrackingCollection(); + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + collection.RaiseChangedDirectly(); + Assert.Equal(1, changeCount); + + collection.RaiseChangedDirectly(); + Assert.Equal(2, changeCount); + } + + // ------------------------------------------------------------------------- + // DeferChangedEvents -- exception safety + // ------------------------------------------------------------------------- + + [Fact] + public void DeferChangedEvents_ExceptionDuringScope_StillFiresChanged() + { + var collection = new McpServerPrimitiveCollection(); + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + try + { + using (collection.DeferChangedEvents()) + { + collection.TryAdd(CreateTool("tool1")); + throw new InvalidOperationException("test"); + } + } + catch (InvalidOperationException) { } + + Assert.Equal(1, changeCount); + } + + [Fact] + public void DeferChangedEvents_ExceptionDuringScope_ResumesImmediateNotificationsAfterward() + { + var collection = new McpServerPrimitiveCollection(); + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + try + { + using (collection.DeferChangedEvents()) + { + collection.TryAdd(CreateTool("tool1")); + throw new InvalidOperationException("test"); + } + } + catch (InvalidOperationException) { } + + Assert.Equal(1, changeCount); + + // Deferral must be fully reset: mutations outside the scope fire immediately. + collection.TryAdd(CreateTool("tool2")); + Assert.Equal(2, changeCount); + + collection.TryAdd(CreateTool("tool3")); + Assert.Equal(3, changeCount); + } + + // ------------------------------------------------------------------------- + // DeferChangedEvents -- prompt collection coverage + // ------------------------------------------------------------------------- + + [Fact] + public void DeferChangedEvents_PromptCollection_MultipleMutations_FiresOneChanged() + { + var collection = new McpServerPrimitiveCollection(); + int changeCount = 0; + collection.Changed += (_, _) => changeCount++; + + using (collection.DeferChangedEvents()) + { + collection.TryAdd(CreatePrompt("prompt1")); + collection.TryAdd(CreatePrompt("prompt2")); + collection.TryAdd(CreatePrompt("prompt3")); + Assert.Equal(0, changeCount); + } + + Assert.Equal(1, changeCount); + Assert.Equal(3, collection.Count); + } +} diff --git a/tests/ModelContextProtocol.Tests/Server/McpServerTaskAugmentedValidationTests.cs b/tests/ModelContextProtocol.Tests/Server/McpServerTaskAugmentedValidationTests.cs deleted file mode 100644 index 4c045cb21..000000000 --- a/tests/ModelContextProtocol.Tests/Server/McpServerTaskAugmentedValidationTests.cs +++ /dev/null @@ -1,1012 +0,0 @@ -using Microsoft.Extensions.DependencyInjection; -using Microsoft.Extensions.Logging; -using ModelContextProtocol.Client; -using ModelContextProtocol.Protocol; -using ModelContextProtocol.Server; -using ModelContextProtocol.Tests.Utils; -using System.Text.Json; - -namespace ModelContextProtocol.Tests.Server; - -/// -/// Tests for validation of task-augmented tool call requests. -/// -public class McpServerTaskAugmentedValidationTests : LoggedTest -{ - public McpServerTaskAugmentedValidationTests(ITestOutputHelper outputHelper) - : base(outputHelper) - { - } - - private static IDictionary CreateArguments(string key, object? value) - { - return new Dictionary - { - [key] = JsonDocument.Parse($"\"{value}\"").RootElement.Clone() - }; - } - - [Fact] - public async Task CallToolAsTask_ThrowsError_WhenNoTaskStoreConfigured() - { - // Arrange - Server WITHOUT task store, but with an async tool (auto-marked as taskSupport: optional) - await using var fixture = new ServerClientFixture(LoggerFactory, configureServer: (services, builder) => - { - // Note: NOT configuring a task store - builder.WithTools([McpServerTool.Create( - async (string input, CancellationToken ct) => - { - await Task.Delay(10, ct); - return $"Result: {input}"; - }, - new McpServerToolCreateOptions - { - Name = "async-tool", - Description = "An async tool" - })]); - }); - - await using var client = await fixture.CreateClientAsync(TestContext.Current.CancellationToken); - - // Act & Assert - Calling with task metadata should fail - var exception = await Assert.ThrowsAsync(async () => - await client.CallToolAsync( - new CallToolRequestParams - { - Name = "async-tool", - Arguments = CreateArguments("input", "test"), - Task = new McpTaskMetadata() - }, - TestContext.Current.CancellationToken)); - - Assert.Contains("not supported", exception.Message, StringComparison.OrdinalIgnoreCase); - } - - [Fact] - public async Task CallToolAsTask_ThrowsError_WhenToolHasForbiddenTaskSupport() - { - // Arrange - Server with task store, but tool has taskSupport: forbidden (sync tool) - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ServerClientFixture(LoggerFactory, configureServer: (services, builder) => - { - services.AddSingleton(taskStore); - services.Configure(options => - { - options.TaskStore = taskStore; - }); - - // Create a synchronous tool - which will have taskSupport: forbidden (default) - builder.WithTools([McpServerTool.Create( - (string input) => $"Result: {input}", - new McpServerToolCreateOptions - { - Name = "sync-tool", - Description = "A synchronous tool that does not support tasks" - })]); - }); - - await using var client = await fixture.CreateClientAsync(TestContext.Current.CancellationToken); - - // Act & Assert - Calling with task metadata should fail because tool doesn't support it - var exception = await Assert.ThrowsAsync(async () => - await client.CallToolAsync( - new CallToolRequestParams - { - Name = "sync-tool", - Arguments = CreateArguments("input", "test"), - Task = new McpTaskMetadata() - }, - TestContext.Current.CancellationToken)); - - Assert.Contains("does not support task-augmented execution", exception.Message, StringComparison.OrdinalIgnoreCase); - Assert.Equal(McpErrorCode.InvalidParams, exception.ErrorCode); - } - - [Fact] - public async Task CallToolAsTask_Succeeds_WhenToolHasOptionalTaskSupport() - { - // Arrange - Server with task store and async tool (auto-marked as taskSupport: optional) - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ServerClientFixture(LoggerFactory, configureServer: (services, builder) => - { - services.AddSingleton(taskStore); - services.Configure(options => - { - options.TaskStore = taskStore; - }); - - builder.WithTools([McpServerTool.Create( - async (string input, CancellationToken ct) => - { - await Task.Delay(10, ct); - return $"Result: {input}"; - }, - new McpServerToolCreateOptions - { - Name = "async-tool", - Description = "An async tool with optional task support" - })]); - }); - - await using var client = await fixture.CreateClientAsync(TestContext.Current.CancellationToken); - - // Act - Calling with task metadata should succeed - var result = await client.CallToolAsync( - new CallToolRequestParams - { - Name = "async-tool", - Arguments = CreateArguments("input", "test"), - Task = new McpTaskMetadata() - }, - TestContext.Current.CancellationToken); - - // Assert - Should return a task - Assert.NotNull(result.Task); - Assert.NotNull(result.Task.TaskId); - } - - [Fact] - public async Task CallToolNormally_Succeeds_WhenToolHasForbiddenTaskSupport() - { - // Arrange - Server with task store, but calling without task metadata - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ServerClientFixture(LoggerFactory, configureServer: (services, builder) => - { - services.AddSingleton(taskStore); - services.Configure(options => - { - options.TaskStore = taskStore; - }); - - builder.WithTools([McpServerTool.Create( - (string input) => $"Result: {input}", - new McpServerToolCreateOptions - { - Name = "sync-tool", - Description = "A synchronous tool" - })]); - }); - - await using var client = await fixture.CreateClientAsync(TestContext.Current.CancellationToken); - - // Act - Calling WITHOUT task metadata should succeed - var result = await client.CallToolAsync( - new CallToolRequestParams - { - Name = "sync-tool", - Arguments = CreateArguments("input", "test"), - }, - TestContext.Current.CancellationToken); - - // Assert - Should return normal result - Assert.NotNull(result.Content); - Assert.Null(result.Task); - } - - [Fact] - public async Task CallToolNormally_ThrowsError_WhenToolHasRequiredTaskSupport() - { - // Arrange - Server with task store and tool with taskSupport: required - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ServerClientFixture(LoggerFactory, configureServer: (services, builder) => - { - services.AddSingleton(taskStore); - services.Configure(options => - { - options.TaskStore = taskStore; - }); - - builder.WithTools([McpServerTool.Create( - async (string input, CancellationToken ct) => - { - await Task.Delay(100, ct); - return $"Result: {input}"; - }, - new McpServerToolCreateOptions - { - Name = "required-task-tool", - Description = "A tool that requires task-augmented execution", - Execution = new ToolExecution { TaskSupport = ToolTaskSupport.Required } - })]); - }); - - await using var client = await fixture.CreateClientAsync(TestContext.Current.CancellationToken); - - // Act & Assert - Calling WITHOUT task metadata should fail - var exception = await Assert.ThrowsAsync(async () => - await client.CallToolAsync( - new CallToolRequestParams - { - Name = "required-task-tool", - Arguments = CreateArguments("input", "test"), - }, - TestContext.Current.CancellationToken)); - - Assert.Contains("requires task-augmented execution", exception.Message, StringComparison.OrdinalIgnoreCase); - Assert.Equal(McpErrorCode.InvalidParams, exception.ErrorCode); - } - - [Fact] - public async Task CallToolAsTask_Succeeds_WhenToolHasRequiredTaskSupport() - { - // Arrange - Server with task store and tool with taskSupport: required - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ServerClientFixture(LoggerFactory, configureServer: (services, builder) => - { - services.AddSingleton(taskStore); - services.Configure(options => - { - options.TaskStore = taskStore; - }); - - builder.WithTools([McpServerTool.Create( - async (string input, CancellationToken ct) => - { - await Task.Delay(10, ct); - return $"Result: {input}"; - }, - new McpServerToolCreateOptions - { - Name = "required-task-tool", - Description = "A tool that requires task-augmented execution", - Execution = new ToolExecution { TaskSupport = ToolTaskSupport.Required } - })]); - }); - - await using var client = await fixture.CreateClientAsync(TestContext.Current.CancellationToken); - - // Act - Calling WITH task metadata should succeed - var result = await client.CallToolAsync( - new CallToolRequestParams - { - Name = "required-task-tool", - Arguments = CreateArguments("input", "test"), - Task = new McpTaskMetadata() - }, - TestContext.Current.CancellationToken); - - // Assert - Should return a task - Assert.NotNull(result.Task); - Assert.NotNull(result.Task.TaskId); - } - - [Fact] - public async Task CallToolAsTask_WithRequiredTaskSupport_CanResolveScopedServicesFromDI() - { - // Regression test for https://github.com/modelcontextprotocol/csharp-sdk/issues/1430: - // ExecuteToolAsTaskAsync fires Task.Run and returns immediately, so the request-scoped - // IServiceProvider owned by InvokeHandlerAsync is disposed before the background task - // calls tool.InvokeAsync. The fix creates a fresh scope inside the Task.Run body so the - // tool can resolve DI services without hitting ObjectDisposedException. - var taskStore = new InMemoryMcpTaskStore(); - string? capturedValue = null; - - await using var fixture = new ServerClientFixture(LoggerFactory, configureServer: (services, builder) => - { - services.AddSingleton(taskStore); - services.Configure(options => options.TaskStore = taskStore); - - // Register a scoped service; resolving it through a disposed scope was the bug. - services.AddScoped(); - - // Register the tool via the factory pattern so that Services = sp is threaded - // through, enabling DI parameter binding at tool-creation time. - builder.Services.AddSingleton(sp => McpServerTool.Create( - async (ITaskToolDiService svc, CancellationToken ct) => - { - await Task.Delay(10, ct); - capturedValue = svc.GetValue(); - return capturedValue; - }, - new McpServerToolCreateOptions - { - Name = "di-required-task-tool", - Services = sp, - Execution = new ToolExecution { TaskSupport = ToolTaskSupport.Required } - })); - }); - - await using var client = await fixture.CreateClientAsync(TestContext.Current.CancellationToken); - - var result = await client.CallToolAsync( - new CallToolRequestParams - { - Name = "di-required-task-tool", - Task = new McpTaskMetadata() - }, - TestContext.Current.CancellationToken); - - Assert.NotNull(result.Task); - string taskId = result.Task.TaskId; - - // Poll until the background task reaches a terminal state. - McpTask taskStatus; - int attempts = 0; - do - { - await Task.Delay(50, TestContext.Current.CancellationToken); - taskStatus = await client.GetTaskAsync(taskId, cancellationToken: TestContext.Current.CancellationToken); - attempts++; - } - while (taskStatus.Status == McpTaskStatus.Working && attempts < 50); - - // Without the fix, the background task would fail with ObjectDisposedException when - // resolving ITaskToolDiService, causing the task to reach McpTaskStatus.Failed. - Assert.Equal(McpTaskStatus.Completed, taskStatus.Status); - Assert.Equal("hello-from-di", capturedValue); - } - - [Fact] - public async Task CallToolAsTaskAsync_WithProgress_CreatesTaskSuccessfully() - { - // Arrange - Server with task store and a tool that reports progress - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ServerClientFixture(LoggerFactory, configureServer: (services, builder) => - { - services.AddSingleton(taskStore); - services.Configure(options => - { - options.TaskStore = taskStore; - }); - - builder.WithTools([McpServerTool.Create( - async (IProgress progress, CancellationToken ct) => - { - // Report progress - progress.Report(new ProgressNotificationValue - { - Progress = 50, - Total = 100, - Message = "Halfway done" - }); - await Task.Delay(10, ct); - return "Completed with progress"; - }, - new McpServerToolCreateOptions - { - Name = "progress-task-tool", - Description = "A tool that reports progress during task execution" - })]); - }); - - await using var client = await fixture.CreateClientAsync(TestContext.Current.CancellationToken); - - // Track progress notifications received by client - var receivedProgressValues = new List(); - IProgress progress = new SynchronousProgress(value => - { - lock (receivedProgressValues) - { - receivedProgressValues.Add(value); - } - }); - - // Act - Call tool as task with progress tracking - var mcpTask = await client.CallToolAsTaskAsync( - "progress-task-tool", - arguments: null, - taskMetadata: new McpTaskMetadata(), - progress: progress, - cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Task was created successfully - Assert.NotNull(mcpTask); - Assert.NotEmpty(mcpTask.TaskId); - - // Note: Progress notifications may not be received for task-augmented calls - // because the notification handler is disposed when the task creation response returns. - // This test verifies the code path executes without errors. - } - - [Fact] - public async Task CallToolAsTaskAsync_WithoutProgress_DoesNotRequireProgressHandler() - { - // Arrange - Server with task store and a tool that reports progress - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ServerClientFixture(LoggerFactory, configureServer: (services, builder) => - { - services.AddSingleton(taskStore); - services.Configure(options => - { - options.TaskStore = taskStore; - }); - - builder.WithTools([McpServerTool.Create( - async (IProgress progress, CancellationToken ct) => - { - // Tool reports progress but client doesn't listen - progress.Report(new ProgressNotificationValue { Progress = 50, Message = "Halfway" }); - await Task.Delay(10, ct); - return "Done"; - }, - new McpServerToolCreateOptions - { - Name = "progress-tool", - Description = "A tool that reports progress" - })]); - }); - - await using var client = await fixture.CreateClientAsync(TestContext.Current.CancellationToken); - - // Act - Call tool as task WITHOUT progress tracking (progress: null) - var mcpTask = await client.CallToolAsTaskAsync( - "progress-tool", - arguments: null, - taskMetadata: new McpTaskMetadata(), - progress: null, // No progress handler - cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Task was still created successfully - Assert.NotNull(mcpTask); - Assert.NotEmpty(mcpTask.TaskId); - } - - private sealed class SynchronousProgress(Action callback) : IProgress - { - public void Report(ProgressNotificationValue value) => callback(value); - } - - #region Error Code Tests for Invalid/Nonexistent TaskId - - [Fact] - public async Task GetTaskAsync_WithNonexistentTaskId_ReturnsInvalidParamsError() - { - // Arrange - Spec: "Invalid or nonexistent taskId in tasks/get: -32602 (Invalid params)" - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ServerClientFixture(LoggerFactory, configureServer: (services, builder) => - { - services.AddSingleton(taskStore); - services.Configure(options => options.TaskStore = taskStore); - builder.WithTools([McpServerTool.Create( - async (CancellationToken ct) => { await Task.Delay(10, ct); return "ok"; }, - new McpServerToolCreateOptions { Name = "test-tool" })]); - }); - - await using var client = await fixture.CreateClientAsync(TestContext.Current.CancellationToken); - - // Act & Assert - var exception = await Assert.ThrowsAsync(async () => - await client.GetTaskAsync("nonexistent-task-id-12345", cancellationToken: TestContext.Current.CancellationToken)); - - Assert.Equal(McpErrorCode.InvalidParams, exception.ErrorCode); - Assert.Contains("not found", exception.Message, StringComparison.OrdinalIgnoreCase); - } - - [Fact] - public async Task GetTaskResultAsync_WithNonexistentTaskId_ReturnsInvalidParamsError() - { - // Arrange - Spec: "Invalid or nonexistent taskId in tasks/result: -32602 (Invalid params)" - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ServerClientFixture(LoggerFactory, configureServer: (services, builder) => - { - services.AddSingleton(taskStore); - services.Configure(options => options.TaskStore = taskStore); - builder.WithTools([McpServerTool.Create( - async (CancellationToken ct) => { await Task.Delay(10, ct); return "ok"; }, - new McpServerToolCreateOptions { Name = "test-tool" })]); - }); - - await using var client = await fixture.CreateClientAsync(TestContext.Current.CancellationToken); - - // Act & Assert - var exception = await Assert.ThrowsAsync(async () => - await client.GetTaskResultAsync("nonexistent-task-id-12345", cancellationToken: TestContext.Current.CancellationToken)); - - Assert.Equal(McpErrorCode.InvalidParams, exception.ErrorCode); - Assert.Contains("not found", exception.Message, StringComparison.OrdinalIgnoreCase); - } - - [Fact] - public async Task CancelTaskAsync_WithNonexistentTaskId_ReturnsError() - { - // Arrange - Spec: "Invalid or nonexistent taskId in tasks/cancel: -32602 (Invalid params)" - // NOTE: Current implementation throws InternalError; this documents actual behavior - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ServerClientFixture(LoggerFactory, configureServer: (services, builder) => - { - services.AddSingleton(taskStore); - services.Configure(options => options.TaskStore = taskStore); - builder.WithTools([McpServerTool.Create( - async (CancellationToken ct) => { await Task.Delay(10, ct); return "ok"; }, - new McpServerToolCreateOptions { Name = "test-tool" })]); - }); - - await using var client = await fixture.CreateClientAsync(TestContext.Current.CancellationToken); - - // Act & Assert - var exception = await Assert.ThrowsAsync(async () => - await client.CancelTaskAsync("nonexistent-task-id-12345", cancellationToken: TestContext.Current.CancellationToken)); - - Assert.NotNull(exception); - } - - [Fact] - public async Task ListTasksAsync_WithInvalidCursor_HandlesGracefully() - { - // Arrange - Spec says: "Invalid or nonexistent cursor in tasks/list: -32602 (Invalid params)" - // Current implementation ignores invalid cursors gracefully - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ServerClientFixture(LoggerFactory, configureServer: (services, builder) => - { - services.AddSingleton(taskStore); - services.Configure(options => options.TaskStore = taskStore); - builder.WithTools([McpServerTool.Create( - async (CancellationToken ct) => { await Task.Delay(10, ct); return "ok"; }, - new McpServerToolCreateOptions { Name = "test-tool" })]); - }); - - await using var client = await fixture.CreateClientAsync(TestContext.Current.CancellationToken); - - // Act - Pass invalid cursor - var result = await client.ListTasksAsync( - new ListTasksRequestParams { Cursor = "invalid-cursor-that-does-not-exist" }, - TestContext.Current.CancellationToken); - - // Assert - Should return valid (possibly empty) result - Assert.NotNull(result.Tasks); - } - - #endregion - - #region Blocking Behavior Tests - - [Fact] - public async Task GetTaskResultAsync_ReturnsImmediately_WhenTaskAlreadyComplete() - { - // Arrange - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ServerClientFixture(LoggerFactory, configureServer: (services, builder) => - { - services.AddSingleton(taskStore); - services.Configure(options => options.TaskStore = taskStore); - builder.WithTools([McpServerTool.Create( - async (CancellationToken ct) => { await Task.Delay(10, ct); return "quick result"; }, - new McpServerToolCreateOptions { Name = "quick-tool" })]); - }); - - await using var client = await fixture.CreateClientAsync(TestContext.Current.CancellationToken); - - // Create and wait for task to complete - var callResult = await client.CallToolAsync( - new CallToolRequestParams - { - Name = "quick-tool", - Arguments = new Dictionary(), - Task = new McpTaskMetadata() - }, - cancellationToken: TestContext.Current.CancellationToken); - - Assert.NotNull(callResult.Task); - string taskId = callResult.Task.TaskId; - - // Wait for task to complete - McpTask taskStatus; - do - { - await Task.Delay(50, TestContext.Current.CancellationToken); - taskStatus = await client.GetTaskAsync(taskId, cancellationToken: TestContext.Current.CancellationToken); - } - while (taskStatus.Status == McpTaskStatus.Working); - - // Act - Get result (should return since task is complete) - var result = await client.GetTaskResultAsync(taskId, cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Should get valid result - Assert.NotEqual(default, result); - } - - [Fact] - public async Task GetTaskResultAsync_ForFailedTask_ReturnsErrorResult() - { - // Arrange - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ServerClientFixture(LoggerFactory, configureServer: (services, builder) => - { - services.AddSingleton(taskStore); - services.Configure(options => options.TaskStore = taskStore); - builder.WithTools([McpServerTool.Create( - async (CancellationToken ct) => - { - await Task.Delay(10, ct); - throw new InvalidOperationException("Tool execution failed intentionally"); -#pragma warning disable CS0162 // Unreachable code detected - return "never"; -#pragma warning restore CS0162 - }, - new McpServerToolCreateOptions { Name = "failable-tool" })]); - }); - - await using var client = await fixture.CreateClientAsync(TestContext.Current.CancellationToken); - - // Create a failing task - var callResult = await client.CallToolAsync( - new CallToolRequestParams - { - Name = "failable-tool", - Arguments = new Dictionary(), - Task = new McpTaskMetadata() - }, - cancellationToken: TestContext.Current.CancellationToken); - - Assert.NotNull(callResult.Task); - string taskId = callResult.Task.TaskId; - - // Wait for task to fail - McpTask taskStatus; - int attempts = 0; - do - { - await Task.Delay(50, TestContext.Current.CancellationToken); - taskStatus = await client.GetTaskAsync(taskId, cancellationToken: TestContext.Current.CancellationToken); - attempts++; - } - while (taskStatus.Status == McpTaskStatus.Working && attempts < 50); - - Assert.Equal(McpTaskStatus.Failed, taskStatus.Status); - - // Act - Get result for failed task - var result = await client.GetTaskResultAsync(taskId, cancellationToken: TestContext.Current.CancellationToken); - var toolResult = result.Deserialize(McpJsonUtilities.DefaultOptions); - - // Assert - Failed task should have isError=true - Assert.NotNull(toolResult); - Assert.True(toolResult.IsError, "Failed task should have isError=true in the result"); - } - - #endregion - - #region Task Consistency and Lifecycle Tests - - [Fact] - public async Task ListTasksAsync_ContainsAllTasksRetrievableByGet() - { - // Arrange - Spec: "If a task is retrievable via tasks/get, it MUST be retrievable via tasks/list" - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ServerClientFixture(LoggerFactory, configureServer: (services, builder) => - { - services.AddSingleton(taskStore); - services.Configure(options => options.TaskStore = taskStore); - builder.WithTools([McpServerTool.Create( - async (string input, CancellationToken ct) => { await Task.Delay(10, ct); return $"Result: {input}"; }, - new McpServerToolCreateOptions { Name = "test-tool" })]); - }); - - await using var client = await fixture.CreateClientAsync(TestContext.Current.CancellationToken); - - // Create multiple tasks - var createdTaskIds = new List(); - for (int i = 0; i < 3; i++) - { - var result = await client.CallToolAsync( - new CallToolRequestParams - { - Name = "test-tool", - Arguments = new Dictionary - { - ["input"] = JsonDocument.Parse($"\"task-{i}\"").RootElement.Clone() - }, - Task = new McpTaskMetadata() - }, - cancellationToken: TestContext.Current.CancellationToken); - - Assert.NotNull(result.Task); - createdTaskIds.Add(result.Task.TaskId); - } - - // Verify each task is retrievable via get - foreach (var taskId in createdTaskIds) - { - var task = await client.GetTaskAsync(taskId, cancellationToken: TestContext.Current.CancellationToken); - Assert.NotNull(task); - } - - // Act - List all tasks - var allTasks = await client.ListTasksAsync(cancellationToken: TestContext.Current.CancellationToken); - - // Assert - All tasks must be in the list - foreach (var taskId in createdTaskIds) - { - Assert.Contains(allTasks, t => t.TaskId == taskId); - } - } - - [Fact] - public async Task NewTask_StartsInWorkingStatus() - { - // Arrange - Spec: "Tasks MUST begin in the working status when created." - var taskStarted = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - var taskCanComplete = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ServerClientFixture(LoggerFactory, configureServer: (services, builder) => - { - services.AddSingleton(taskStore); - services.Configure(options => options.TaskStore = taskStore); - builder.WithTools([McpServerTool.Create( - async (CancellationToken ct) => - { - taskStarted.TrySetResult(true); - await taskCanComplete.Task.WaitAsync(ct); - return "done"; - }, - new McpServerToolCreateOptions { Name = "controllable-tool" })]); - }); - - await using var client = await fixture.CreateClientAsync(TestContext.Current.CancellationToken); - - // Act - Create a task - var callResult = await client.CallToolAsync( - new CallToolRequestParams - { - Name = "controllable-tool", - Arguments = new Dictionary(), - Task = new McpTaskMetadata() - }, - cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Assert.NotNull(callResult.Task); - Assert.Equal(McpTaskStatus.Working, callResult.Task.Status); - - // Cleanup - taskCanComplete.TrySetResult(true); - } - - [Fact] - public async Task Task_ContainsRequiredTimestamps() - { - // Arrange - Spec: "Receivers MUST include createdAt and lastUpdatedAt timestamps" - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ServerClientFixture(LoggerFactory, configureServer: (services, builder) => - { - services.AddSingleton(taskStore); - services.Configure(options => options.TaskStore = taskStore); - builder.WithTools([McpServerTool.Create( - async (CancellationToken ct) => { await Task.Delay(10, ct); return "ok"; }, - new McpServerToolCreateOptions { Name = "test-tool" })]); - }); - - await using var client = await fixture.CreateClientAsync(TestContext.Current.CancellationToken); - - var beforeCreation = DateTimeOffset.UtcNow; - - // Act - var callResult = await client.CallToolAsync( - new CallToolRequestParams - { - Name = "test-tool", - Arguments = new Dictionary(), - Task = new McpTaskMetadata() - }, - cancellationToken: TestContext.Current.CancellationToken); - - var afterCreation = DateTimeOffset.UtcNow; - - // Assert - Assert.NotNull(callResult.Task); - Assert.NotEqual(default, callResult.Task.CreatedAt); - Assert.NotEqual(default, callResult.Task.LastUpdatedAt); - Assert.True(callResult.Task.CreatedAt >= beforeCreation.AddSeconds(-1)); - Assert.True(callResult.Task.CreatedAt <= afterCreation.AddSeconds(1)); - } - - [Fact] - public async Task Task_IncludesTtlInResponse() - { - // Arrange - Spec: "Receivers MUST include the actual ttl duration in tasks/get responses." - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ServerClientFixture(LoggerFactory, configureServer: (services, builder) => - { - services.AddSingleton(taskStore); - services.Configure(options => options.TaskStore = taskStore); - builder.WithTools([McpServerTool.Create( - async (CancellationToken ct) => { await Task.Delay(10, ct); return "ok"; }, - new McpServerToolCreateOptions { Name = "test-tool" })]); - }); - - await using var client = await fixture.CreateClientAsync(TestContext.Current.CancellationToken); - - // Act - var callResult = await client.CallToolAsync( - new CallToolRequestParams - { - Name = "test-tool", - Arguments = new Dictionary(), - Task = new McpTaskMetadata { TimeToLive = TimeSpan.FromMinutes(30) } - }, - cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Assert.NotNull(callResult.Task); - Assert.NotNull(callResult.Task.TimeToLive); - - var taskStatus = await client.GetTaskAsync(callResult.Task.TaskId, cancellationToken: TestContext.Current.CancellationToken); - Assert.NotNull(taskStatus.TimeToLive); - } - - [Fact] - public async Task Task_IncludesPollIntervalInResponse() - { - // Arrange - Spec: "Receivers MAY include a pollInterval value" - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ServerClientFixture(LoggerFactory, configureServer: (services, builder) => - { - services.AddSingleton(taskStore); - services.Configure(options => options.TaskStore = taskStore); - builder.WithTools([McpServerTool.Create( - async (CancellationToken ct) => { await Task.Delay(10, ct); return "ok"; }, - new McpServerToolCreateOptions { Name = "test-tool" })]); - }); - - await using var client = await fixture.CreateClientAsync(TestContext.Current.CancellationToken); - - // Act - var callResult = await client.CallToolAsync( - new CallToolRequestParams - { - Name = "test-tool", - Arguments = new Dictionary(), - Task = new McpTaskMetadata() - }, - cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Assert.NotNull(callResult.Task); - Assert.NotNull(callResult.Task.PollInterval); - } - - #endregion - - #region Server Without Tasks Capability Tests - - [Fact] - public async Task ServerCapabilities_DoNotIncludeTasks_WhenNoTaskStore() - { - // Arrange - Spec: "If capabilities.tasks is not defined, the peer SHOULD NOT attempt to create tasks" - await using var fixture = new ServerClientFixture(LoggerFactory, configureServer: (services, builder) => - { - // NOT configuring a task store - builder.WithTools([McpServerTool.Create( - async (CancellationToken ct) => { await Task.Delay(10, ct); return "ok"; }, - new McpServerToolCreateOptions { Name = "async-tool" })]); - }); - - await using var client = await fixture.CreateClientAsync(TestContext.Current.CancellationToken); - - // Assert - Assert.Null(client.ServerCapabilities?.Tasks); - } - - [Fact] - public async Task NormalRequest_Succeeds_WhenTasksNotSupported() - { - // Arrange - Normal requests should work without task support - await using var fixture = new ServerClientFixture(LoggerFactory, configureServer: (services, builder) => - { - builder.WithTools([McpServerTool.Create( - (string input) => $"Sync result: {input}", - new McpServerToolCreateOptions { Name = "sync-tool" })]); - }); - - await using var client = await fixture.CreateClientAsync(TestContext.Current.CancellationToken); - - // Act - var result = await client.CallToolAsync( - new CallToolRequestParams - { - Name = "sync-tool", - Arguments = CreateArguments("input", "test") - }, - cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Assert.NotNull(result.Content); - Assert.Null(result.Task); - } - - #endregion - - private interface ITaskToolDiService - { - string GetValue(); - } - - private sealed class TaskToolDiService : ITaskToolDiService - { - public string GetValue() => "hello-from-di"; - } - - /// - /// Helper fixture for creating server-client pairs with custom configuration. - /// - private sealed class ServerClientFixture : IAsyncDisposable - { - private readonly System.IO.Pipelines.Pipe _clientToServerPipe = new(); - private readonly System.IO.Pipelines.Pipe _serverToClientPipe = new(); - private readonly IServiceProvider _serviceProvider; - private readonly McpServer _server; - private readonly Task _serverTask; - private readonly CancellationTokenSource _cts; - private readonly ILoggerFactory _loggerFactory; - - public ServerClientFixture( - ILoggerFactory loggerFactory, - Action? configureServer = null) - { - _loggerFactory = loggerFactory; - _cts = new CancellationTokenSource(); - - var services = new ServiceCollection(); - services.AddLogging(); - services.AddSingleton(loggerFactory); - - var builder = services - .AddMcpServer() - .WithStreamServerTransport( - _clientToServerPipe.Reader.AsStream(), - _serverToClientPipe.Writer.AsStream()); - - configureServer?.Invoke(services, builder); - - _serviceProvider = services.BuildServiceProvider(validateScopes: true); - _server = _serviceProvider.GetRequiredService(); - _serverTask = _server.RunAsync(_cts.Token); - } - - public async Task CreateClientAsync(CancellationToken cancellationToken) - { - return await McpClient.CreateAsync( - new StreamClientTransport( - serverInput: _clientToServerPipe.Writer.AsStream(), - _serverToClientPipe.Reader.AsStream(), - _loggerFactory), - loggerFactory: _loggerFactory, - cancellationToken: cancellationToken); - } - - public async ValueTask DisposeAsync() - { - await _cts.CancelAsync(); - - _clientToServerPipe.Writer.Complete(); - _serverToClientPipe.Writer.Complete(); - - try - { - await _serverTask; - } - catch (OperationCanceledException) - { - // Expected - } - - if (_serviceProvider is IAsyncDisposable asyncDisposable) - { - await asyncDisposable.DisposeAsync(); - } - else if (_serviceProvider is IDisposable disposable) - { - disposable.Dispose(); - } - - _cts.Dispose(); - } - } -} diff --git a/tests/ModelContextProtocol.Tests/Server/McpServerTaskMethodsTests.cs b/tests/ModelContextProtocol.Tests/Server/McpServerTaskMethodsTests.cs deleted file mode 100644 index d908bbb7f..000000000 --- a/tests/ModelContextProtocol.Tests/Server/McpServerTaskMethodsTests.cs +++ /dev/null @@ -1,762 +0,0 @@ -using ModelContextProtocol.Protocol; -using ModelContextProtocol.Server; -using ModelContextProtocol.Tests.Utils; -using System.Runtime.InteropServices; -using System.Text.Json; - -namespace ModelContextProtocol.Tests.Server; - -/// -/// Tests for McpServer methods that query tasks on the client (Phase 4 implementation). -/// -public class McpServerTaskMethodsTests : LoggedTest -{ - private readonly McpServerOptions _options; - - public McpServerTaskMethodsTests(ITestOutputHelper testOutputHelper) - : base(testOutputHelper) - { -#if !NET - Assert.SkipWhen(RuntimeInformation.IsOSPlatform(OSPlatform.Windows), "https://github.com/modelcontextprotocol/csharp-sdk/issues/587"); -#endif - _options = CreateOptions(); - } - - private static McpServerOptions CreateOptions(ServerCapabilities? capabilities = null) - { - return new McpServerOptions - { - ProtocolVersion = "2024", - InitializationTimeout = TimeSpan.FromSeconds(30), - Capabilities = capabilities, - }; - } - - #region SampleAsTaskAsync Tests - - [Fact] - public async Task SampleAsTaskAsync_ThrowsException_WhenClientDoesNotSupportSampling() - { - // Arrange - await using var transport = new TestServerTransport(); - await using var server = McpServer.Create(transport, _options, LoggerFactory); - var runTask = server.RunAsync(TestContext.Current.CancellationToken); - await InitializeServerAsync(transport, new ClientCapabilities(), TestContext.Current.CancellationToken); - - // Act & Assert - await Assert.ThrowsAsync(async () => - await server.SampleAsTaskAsync( - new CreateMessageRequestParams { Messages = [], MaxTokens = 1000 }, - new McpTaskMetadata(), - CancellationToken.None)); - - await transport.DisposeAsync(); - await runTask; - } - - [Fact] - public async Task SampleAsTaskAsync_ThrowsException_WhenClientDoesNotSupportTaskAugmentedSampling() - { - // Arrange - Client supports sampling but NOT task-augmented sampling - await using var transport = new TestServerTransport(); - await using var server = McpServer.Create(transport, _options, LoggerFactory); - var runTask = server.RunAsync(TestContext.Current.CancellationToken); - await InitializeServerAsync(transport, new ClientCapabilities - { - Sampling = new SamplingCapability(), - // Note: No Tasks capability - }, TestContext.Current.CancellationToken); - - // Act & Assert - await Assert.ThrowsAsync(async () => - await server.SampleAsTaskAsync( - new CreateMessageRequestParams { Messages = [], MaxTokens = 1000 }, - new McpTaskMetadata(), - CancellationToken.None)); - - await transport.DisposeAsync(); - await runTask; - } - - [Fact] - public async Task SampleAsTaskAsync_SendsRequest_WhenClientSupportsTaskAugmentedSampling() - { - // Arrange - await using var transport = new TestServerTransport(); - - // Configure transport to return a task result for sampling - transport.MockTask = new McpTask - { - TaskId = "sample-task-123", - Status = McpTaskStatus.Working, - CreatedAt = DateTimeOffset.UtcNow, - LastUpdatedAt = DateTimeOffset.UtcNow, - }; - - await using var server = McpServer.Create(transport, _options, LoggerFactory); - var runTask = server.RunAsync(TestContext.Current.CancellationToken); - await InitializeServerAsync(transport, new ClientCapabilities - { - Sampling = new SamplingCapability(), - Tasks = new McpTasksCapability - { - Requests = new RequestMcpTasksCapability - { - Sampling = new SamplingMcpTasksCapability - { - CreateMessage = new CreateMessageMcpTasksCapability() - } - } - } - }, TestContext.Current.CancellationToken); - - // Act - var task = await server.SampleAsTaskAsync( - new CreateMessageRequestParams { Messages = [], MaxTokens = 1000 }, - new McpTaskMetadata { TimeToLive = TimeSpan.FromMinutes(5) }, - TestContext.Current.CancellationToken); - - // Assert - Assert.NotNull(task); - Assert.Equal("sample-task-123", task.TaskId); - Assert.Equal(McpTaskStatus.Working, task.Status); - - // Verify the request was sent with task metadata - var samplingRequest = transport.SentMessages.OfType() - .FirstOrDefault(r => r.Method == RequestMethods.SamplingCreateMessage); - Assert.NotNull(samplingRequest); - var requestParams = JsonSerializer.Deserialize( - samplingRequest.Params, McpJsonUtilities.DefaultOptions); - Assert.NotNull(requestParams?.Task); - - await transport.DisposeAsync(); - await runTask; - } - - #endregion - - #region ElicitAsTaskAsync Tests - - [Fact] - public async Task ElicitAsTaskAsync_ThrowsException_WhenClientDoesNotSupportElicitation() - { - // Arrange - await using var transport = new TestServerTransport(); - await using var server = McpServer.Create(transport, _options, LoggerFactory); - var runTask = server.RunAsync(TestContext.Current.CancellationToken); - await InitializeServerAsync(transport, new ClientCapabilities(), TestContext.Current.CancellationToken); - - // Act & Assert - await Assert.ThrowsAsync(async () => - await server.ElicitAsTaskAsync( - new ElicitRequestParams { Message = "test", RequestedSchema = new() }, - new McpTaskMetadata(), - CancellationToken.None)); - - await transport.DisposeAsync(); - await runTask; - } - - [Fact] - public async Task ElicitAsTaskAsync_ThrowsException_WhenClientDoesNotSupportTaskAugmentedElicitation() - { - // Arrange - Client supports elicitation but NOT task-augmented elicitation - await using var transport = new TestServerTransport(); - await using var server = McpServer.Create(transport, _options, LoggerFactory); - var runTask = server.RunAsync(TestContext.Current.CancellationToken); - await InitializeServerAsync(transport, new ClientCapabilities - { - Elicitation = new ElicitationCapability { Form = new() }, - // Note: No Tasks capability - }, TestContext.Current.CancellationToken); - - // Act & Assert - await Assert.ThrowsAsync(async () => - await server.ElicitAsTaskAsync( - new ElicitRequestParams { Message = "test", RequestedSchema = new() }, - new McpTaskMetadata(), - CancellationToken.None)); - - await transport.DisposeAsync(); - await runTask; - } - - [Fact] - public async Task ElicitAsTaskAsync_SendsRequest_WhenClientSupportsTaskAugmentedElicitation() - { - // Arrange - await using var transport = new TestServerTransport(); - - // Configure transport to return a task result for elicitation - transport.MockTask = new McpTask - { - TaskId = "elicit-task-456", - Status = McpTaskStatus.Working, - CreatedAt = DateTimeOffset.UtcNow, - LastUpdatedAt = DateTimeOffset.UtcNow, - }; - - await using var server = McpServer.Create(transport, _options, LoggerFactory); - var runTask = server.RunAsync(TestContext.Current.CancellationToken); - await InitializeServerAsync(transport, new ClientCapabilities - { - Elicitation = new ElicitationCapability { Form = new() }, - Tasks = new McpTasksCapability - { - Requests = new RequestMcpTasksCapability - { - Elicitation = new ElicitationMcpTasksCapability - { - Create = new CreateElicitationMcpTasksCapability() - } - } - } - }, TestContext.Current.CancellationToken); - - // Act - var task = await server.ElicitAsTaskAsync( - new ElicitRequestParams { Message = "Please provide input", RequestedSchema = new() }, - new McpTaskMetadata { TimeToLive = TimeSpan.FromMinutes(10) }, - TestContext.Current.CancellationToken); - - // Assert - Assert.NotNull(task); - Assert.Equal("elicit-task-456", task.TaskId); - Assert.Equal(McpTaskStatus.Working, task.Status); - - await transport.DisposeAsync(); - await runTask; - } - - #endregion - - #region GetTaskAsync Tests - - [Fact] - public async Task GetTaskAsync_ThrowsException_WhenClientDoesNotSupportTasks() - { - // Arrange - await using var transport = new TestServerTransport(); - await using var server = McpServer.Create(transport, _options, LoggerFactory); - var runTask = server.RunAsync(TestContext.Current.CancellationToken); - await InitializeServerAsync(transport, new ClientCapabilities(), TestContext.Current.CancellationToken); - - // Act & Assert - await Assert.ThrowsAsync(async () => - await server.GetTaskAsync("task-id", CancellationToken.None)); - - await transport.DisposeAsync(); - await runTask; - } - - [Fact] - public async Task GetTaskAsync_SendsRequest_AndReturnsTask() - { - // Arrange - await using var transport = new TestServerTransport(); - transport.MockTask = new McpTask - { - TaskId = "client-task-789", - Status = McpTaskStatus.Completed, - StatusMessage = "Task completed successfully", - CreatedAt = DateTimeOffset.UtcNow.AddMinutes(-5), - LastUpdatedAt = DateTimeOffset.UtcNow, - }; - - await using var server = McpServer.Create(transport, _options, LoggerFactory); - var runTask = server.RunAsync(TestContext.Current.CancellationToken); - await InitializeServerAsync(transport, new ClientCapabilities - { - Tasks = new McpTasksCapability() - }, TestContext.Current.CancellationToken); - - // Act - var task = await server.GetTaskAsync("client-task-789", TestContext.Current.CancellationToken); - - // Assert - Assert.NotNull(task); - Assert.Equal("client-task-789", task.TaskId); - Assert.Equal(McpTaskStatus.Completed, task.Status); - - // Verify the request was sent - var taskRequest = transport.SentMessages.OfType() - .FirstOrDefault(r => r.Method == RequestMethods.TasksGet); - Assert.NotNull(taskRequest); - - await transport.DisposeAsync(); - await runTask; - } - - [Fact] - public async Task GetTaskAsync_ThrowsArgumentException_WhenTaskIdIsEmpty() - { - // Arrange - await using var transport = new TestServerTransport(); - await using var server = McpServer.Create(transport, _options, LoggerFactory); - var runTask = server.RunAsync(TestContext.Current.CancellationToken); - await InitializeServerAsync(transport, new ClientCapabilities - { - Tasks = new McpTasksCapability() - }, TestContext.Current.CancellationToken); - - // Act & Assert - await Assert.ThrowsAsync(async () => - await server.GetTaskAsync("", CancellationToken.None)); - - await transport.DisposeAsync(); - await runTask; - } - - #endregion - - #region GetTaskResultAsync Tests - - [Fact] - public async Task GetTaskResultAsync_ThrowsException_WhenClientDoesNotSupportTasks() - { - // Arrange - await using var transport = new TestServerTransport(); - await using var server = McpServer.Create(transport, _options, LoggerFactory); - var runTask = server.RunAsync(TestContext.Current.CancellationToken); - await InitializeServerAsync(transport, new ClientCapabilities(), TestContext.Current.CancellationToken); - - // Act & Assert - await Assert.ThrowsAsync(async () => - await server.GetTaskResultAsync("task-id", cancellationToken: CancellationToken.None)); - - await transport.DisposeAsync(); - await runTask; - } - - [Fact] - public async Task GetTaskResultAsync_ReturnsDeserializedResult() - { - // Arrange - await using var transport = new TestServerTransport(); - transport.MockTaskResult = new CreateMessageResult - { - Content = [new TextContentBlock { Text = "Hello from task result!" }], - Model = "gpt-4" - }; - - await using var server = McpServer.Create(transport, _options, LoggerFactory); - var runTask = server.RunAsync(TestContext.Current.CancellationToken); - await InitializeServerAsync(transport, new ClientCapabilities - { - Tasks = new McpTasksCapability() - }, TestContext.Current.CancellationToken); - - // Act - var result = await server.GetTaskResultAsync( - "task-id", cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Assert.NotNull(result); - Assert.Equal("gpt-4", result.Model); - Assert.Single(result.Content); - var textContent = Assert.IsType(result.Content[0]); - Assert.Equal("Hello from task result!", textContent.Text); - - await transport.DisposeAsync(); - await runTask; - } - - #endregion - - #region ListTasksAsync Tests - - [Fact] - public async Task ListTasksAsync_ThrowsException_WhenClientDoesNotSupportTasks() - { - // Arrange - await using var transport = new TestServerTransport(); - await using var server = McpServer.Create(transport, _options, LoggerFactory); - var runTask = server.RunAsync(TestContext.Current.CancellationToken); - await InitializeServerAsync(transport, new ClientCapabilities(), TestContext.Current.CancellationToken); - - // Act & Assert - await Assert.ThrowsAsync(async () => - await server.ListTasksAsync(CancellationToken.None)); - - await transport.DisposeAsync(); - await runTask; - } - - [Fact] - public async Task ListTasksAsync_ThrowsException_WhenClientDoesNotSupportTaskListing() - { - // Arrange - Client supports tasks but NOT task listing - await using var transport = new TestServerTransport(); - await using var server = McpServer.Create(transport, _options, LoggerFactory); - var runTask = server.RunAsync(TestContext.Current.CancellationToken); - await InitializeServerAsync(transport, new ClientCapabilities - { - Tasks = new McpTasksCapability - { - // Note: No List capability - } - }, TestContext.Current.CancellationToken); - - // Act & Assert - await Assert.ThrowsAsync(async () => - await server.ListTasksAsync(CancellationToken.None)); - - await transport.DisposeAsync(); - await runTask; - } - - [Fact] - public async Task ListTasksAsync_ReturnsTaskList() - { - // Arrange - await using var transport = new TestServerTransport(); - transport.MockTaskList = - [ - new McpTask - { - TaskId = "task-a", - Status = McpTaskStatus.Completed, - CreatedAt = DateTimeOffset.UtcNow.AddMinutes(-10), - LastUpdatedAt = DateTimeOffset.UtcNow, - }, - new McpTask - { - TaskId = "task-b", - Status = McpTaskStatus.Working, - CreatedAt = DateTimeOffset.UtcNow.AddMinutes(-5), - LastUpdatedAt = DateTimeOffset.UtcNow, - }, - new McpTask - { - TaskId = "task-c", - Status = McpTaskStatus.Failed, - StatusMessage = "Task failed", - CreatedAt = DateTimeOffset.UtcNow.AddMinutes(-2), - LastUpdatedAt = DateTimeOffset.UtcNow, - } - ]; - - await using var server = McpServer.Create(transport, _options, LoggerFactory); - var runTask = server.RunAsync(TestContext.Current.CancellationToken); - await InitializeServerAsync(transport, new ClientCapabilities - { - Tasks = new McpTasksCapability - { - List = new ListMcpTasksCapability() - } - }, TestContext.Current.CancellationToken); - - // Act - var tasks = await server.ListTasksAsync(TestContext.Current.CancellationToken); - - // Assert - Assert.NotNull(tasks); - Assert.Equal(3, tasks.Count); - Assert.Equal("task-a", tasks[0].TaskId); - Assert.Equal("task-b", tasks[1].TaskId); - Assert.Equal("task-c", tasks[2].TaskId); - - await transport.DisposeAsync(); - await runTask; - } - - #endregion - - #region CancelTaskAsync Tests - - [Fact] - public async Task CancelTaskAsync_ThrowsException_WhenClientDoesNotSupportTasks() - { - // Arrange - await using var transport = new TestServerTransport(); - await using var server = McpServer.Create(transport, _options, LoggerFactory); - var runTask = server.RunAsync(TestContext.Current.CancellationToken); - await InitializeServerAsync(transport, new ClientCapabilities(), TestContext.Current.CancellationToken); - - // Act & Assert - await Assert.ThrowsAsync(async () => - await server.CancelTaskAsync("task-id", CancellationToken.None)); - - await transport.DisposeAsync(); - await runTask; - } - - [Fact] - public async Task CancelTaskAsync_ThrowsException_WhenClientDoesNotSupportTaskCancellation() - { - // Arrange - Client supports tasks but NOT task cancellation - await using var transport = new TestServerTransport(); - await using var server = McpServer.Create(transport, _options, LoggerFactory); - var runTask = server.RunAsync(TestContext.Current.CancellationToken); - await InitializeServerAsync(transport, new ClientCapabilities - { - Tasks = new McpTasksCapability - { - // Note: No Cancel capability - } - }, TestContext.Current.CancellationToken); - - // Act & Assert - await Assert.ThrowsAsync(async () => - await server.CancelTaskAsync("task-id", CancellationToken.None)); - - await transport.DisposeAsync(); - await runTask; - } - - [Fact] - public async Task CancelTaskAsync_SendsRequest_AndReturnsCancelledTask() - { - // Arrange - await using var transport = new TestServerTransport(); - transport.MockTask = new McpTask - { - TaskId = "task-to-cancel", - Status = McpTaskStatus.Working, - CreatedAt = DateTimeOffset.UtcNow.AddMinutes(-3), - LastUpdatedAt = DateTimeOffset.UtcNow, - }; - - await using var server = McpServer.Create(transport, _options, LoggerFactory); - var runTask = server.RunAsync(TestContext.Current.CancellationToken); - await InitializeServerAsync(transport, new ClientCapabilities - { - Tasks = new McpTasksCapability - { - Cancel = new CancelMcpTasksCapability() - } - }, TestContext.Current.CancellationToken); - - // Act - var task = await server.CancelTaskAsync("task-to-cancel", TestContext.Current.CancellationToken); - - // Assert - Assert.NotNull(task); - Assert.Equal("task-to-cancel", task.TaskId); - Assert.Equal(McpTaskStatus.Cancelled, task.Status); - - // Verify the request was sent - var cancelRequest = transport.SentMessages.OfType() - .FirstOrDefault(r => r.Method == RequestMethods.TasksCancel); - Assert.NotNull(cancelRequest); - - await transport.DisposeAsync(); - await runTask; - } - - #endregion - - #region PollTaskUntilCompleteAsync Tests - - [Fact] - public async Task PollTaskUntilCompleteAsync_ReturnsImmediately_WhenTaskIsAlreadyComplete() - { - // Arrange - await using var transport = new TestServerTransport(); - transport.MockTask = new McpTask - { - TaskId = "completed-task", - Status = McpTaskStatus.Completed, - CreatedAt = DateTimeOffset.UtcNow.AddMinutes(-5), - LastUpdatedAt = DateTimeOffset.UtcNow, - }; - - await using var server = McpServer.Create(transport, _options, LoggerFactory); - var runTask = server.RunAsync(TestContext.Current.CancellationToken); - await InitializeServerAsync(transport, new ClientCapabilities - { - Tasks = new McpTasksCapability() - }, TestContext.Current.CancellationToken); - - // Act - var task = await server.PollTaskUntilCompleteAsync("completed-task", TestContext.Current.CancellationToken); - - // Assert - Assert.NotNull(task); - Assert.Equal("completed-task", task.TaskId); - Assert.Equal(McpTaskStatus.Completed, task.Status); - - await transport.DisposeAsync(); - await runTask; - } - - [Fact] - public async Task PollTaskUntilCompleteAsync_ReturnsTask_WhenTaskFails() - { - // Arrange - await using var transport = new TestServerTransport(); - transport.MockTask = new McpTask - { - TaskId = "failed-task", - Status = McpTaskStatus.Failed, - StatusMessage = "Task execution failed", - CreatedAt = DateTimeOffset.UtcNow.AddMinutes(-5), - LastUpdatedAt = DateTimeOffset.UtcNow, - }; - - await using var server = McpServer.Create(transport, _options, LoggerFactory); - var runTask = server.RunAsync(TestContext.Current.CancellationToken); - await InitializeServerAsync(transport, new ClientCapabilities - { - Tasks = new McpTasksCapability() - }, TestContext.Current.CancellationToken); - - // Act - var task = await server.PollTaskUntilCompleteAsync("failed-task", TestContext.Current.CancellationToken); - - // Assert - Assert.NotNull(task); - Assert.Equal("failed-task", task.TaskId); - Assert.Equal(McpTaskStatus.Failed, task.Status); - Assert.Equal("Task execution failed", task.StatusMessage); - - await transport.DisposeAsync(); - await runTask; - } - - #endregion - - #region WaitForTaskResultAsync Tests - - [Fact] - public async Task WaitForTaskResultAsync_ReturnsTaskAndResult_WhenTaskCompletes() - { - // Arrange - await using var transport = new TestServerTransport(); - transport.MockTask = new McpTask - { - TaskId = "task-with-result", - Status = McpTaskStatus.Completed, - CreatedAt = DateTimeOffset.UtcNow.AddMinutes(-5), - LastUpdatedAt = DateTimeOffset.UtcNow, - }; - transport.MockTaskResult = new CreateMessageResult - { - Content = [new TextContentBlock { Text = "Final result from task" }], - Model = "test-model" - }; - - await using var server = McpServer.Create(transport, _options, LoggerFactory); - var runTask = server.RunAsync(TestContext.Current.CancellationToken); - await InitializeServerAsync(transport, new ClientCapabilities - { - Tasks = new McpTasksCapability() - }, TestContext.Current.CancellationToken); - - // Act - var (task, result) = await server.WaitForTaskResultAsync( - "task-with-result", cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Assert.NotNull(task); - Assert.Equal("task-with-result", task.TaskId); - Assert.Equal(McpTaskStatus.Completed, task.Status); - - Assert.NotNull(result); - Assert.Equal("test-model", result.Model); - var textContent = Assert.IsType(Assert.Single(result.Content)); - Assert.Equal("Final result from task", textContent.Text); - - await transport.DisposeAsync(); - await runTask; - } - - [Fact] - public async Task WaitForTaskResultAsync_ThrowsException_WhenTaskFails() - { - // Arrange - await using var transport = new TestServerTransport(); - transport.MockTask = new McpTask - { - TaskId = "failed-task", - Status = McpTaskStatus.Failed, - StatusMessage = "Something went wrong", - CreatedAt = DateTimeOffset.UtcNow.AddMinutes(-5), - LastUpdatedAt = DateTimeOffset.UtcNow, - }; - - await using var server = McpServer.Create(transport, _options, LoggerFactory); - var runTask = server.RunAsync(TestContext.Current.CancellationToken); - await InitializeServerAsync(transport, new ClientCapabilities - { - Tasks = new McpTasksCapability() - }, TestContext.Current.CancellationToken); - - // Act & Assert - var ex = await Assert.ThrowsAsync(async () => - await server.WaitForTaskResultAsync( - "failed-task", cancellationToken: TestContext.Current.CancellationToken)); - - Assert.Contains("failed", ex.Message, StringComparison.OrdinalIgnoreCase); - Assert.Contains("Something went wrong", ex.Message); - - await transport.DisposeAsync(); - await runTask; - } - - [Fact] - public async Task WaitForTaskResultAsync_ThrowsException_WhenTaskIsCancelled() - { - // Arrange - await using var transport = new TestServerTransport(); - transport.MockTask = new McpTask - { - TaskId = "cancelled-task", - Status = McpTaskStatus.Cancelled, - CreatedAt = DateTimeOffset.UtcNow.AddMinutes(-5), - LastUpdatedAt = DateTimeOffset.UtcNow, - }; - - await using var server = McpServer.Create(transport, _options, LoggerFactory); - var runTask = server.RunAsync(TestContext.Current.CancellationToken); - await InitializeServerAsync(transport, new ClientCapabilities - { - Tasks = new McpTasksCapability() - }, TestContext.Current.CancellationToken); - - // Act & Assert - var ex = await Assert.ThrowsAsync(async () => - await server.WaitForTaskResultAsync( - "cancelled-task", cancellationToken: TestContext.Current.CancellationToken)); - - Assert.Contains("cancelled", ex.Message, StringComparison.OrdinalIgnoreCase); - - await transport.DisposeAsync(); - await runTask; - } - - #endregion - - #region Helper Methods - - private static async Task InitializeServerAsync(TestServerTransport transport, ClientCapabilities capabilities, CancellationToken cancellationToken = default) - { - var initializeRequest = new JsonRpcRequest - { - Id = new RequestId("init-1"), - Method = RequestMethods.Initialize, - Params = JsonSerializer.SerializeToNode(new InitializeRequestParams - { - ProtocolVersion = "2024-11-05", - Capabilities = capabilities, - ClientInfo = new Implementation { Name = "test-client", Version = "1.0.0" } - }, McpJsonUtilities.DefaultOptions) - }; - - var tcs = new TaskCompletionSource(); - transport.OnMessageSent = (message) => - { - if (message is JsonRpcResponse response && response.Id == initializeRequest.Id) - { - tcs.TrySetResult(true); - } - }; - - await transport.SendClientMessageAsync(initializeRequest, cancellationToken); - - // Wait for the initialize response to be sent - await tcs.Task.WaitAsync(TestConstants.DefaultTimeout, cancellationToken); - } - - #endregion -} diff --git a/tests/ModelContextProtocol.Tests/Server/McpServerTaskNotificationTests.cs b/tests/ModelContextProtocol.Tests/Server/McpServerTaskNotificationTests.cs deleted file mode 100644 index aa8941864..000000000 --- a/tests/ModelContextProtocol.Tests/Server/McpServerTaskNotificationTests.cs +++ /dev/null @@ -1,152 +0,0 @@ -using ModelContextProtocol.Client; -using ModelContextProtocol.Protocol; -using ModelContextProtocol.Server; -using System.Collections.Concurrent; -using System.Text.Json; - -namespace ModelContextProtocol.Tests.Server; - -/// -/// Tests for task status notification functionality in McpServer. -/// -public class McpServerTaskNotificationTests : ClientServerTestBase -{ - public McpServerTaskNotificationTests(ITestOutputHelper testOutputHelper) - : base(testOutputHelper) - { - } - - [Fact] - public async Task NotifyTaskStatusAsync_SendsNotificationWithTaskDetails() - { - // Arrange - var client = await CreateMcpClientForServer(); - var tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - - await using var registration = client.RegisterNotificationHandler( - NotificationMethods.TaskStatusNotification, - (notification, cancellationToken) => - { - if (notification.Params is { } paramsNode) - { - var notificationParams = JsonSerializer.Deserialize(paramsNode, McpJsonUtilities.DefaultOptions); - if (notificationParams is not null) - { - tcs.TrySetResult(notificationParams); - } - } - return default; - }); - - var mcpTask = new McpTask - { - TaskId = "task-123", - Status = McpTaskStatus.Working, - StatusMessage = "Processing request", - CreatedAt = DateTimeOffset.UtcNow.AddMinutes(-1), - LastUpdatedAt = DateTimeOffset.UtcNow, - TimeToLive = TimeSpan.FromMinutes(10), - PollInterval = TimeSpan.FromSeconds(1) - }; - - // Act - await Server.NotifyTaskStatusAsync(mcpTask, TestContext.Current.CancellationToken); - var notification = await tcs.Task.WaitAsync(TestContext.Current.CancellationToken); - - // Assert - Assert.Equal(mcpTask.TaskId, notification.TaskId); - Assert.Equal(mcpTask.Status, notification.Status); - Assert.Equal(mcpTask.StatusMessage, notification.StatusMessage); - Assert.Equal(mcpTask.CreatedAt, notification.CreatedAt); - Assert.Equal(mcpTask.LastUpdatedAt, notification.LastUpdatedAt); - Assert.Equal(mcpTask.TimeToLive, notification.TimeToLive); - Assert.Equal(mcpTask.PollInterval, notification.PollInterval); - } - - [Fact] - public async Task NotifyTaskStatusAsync_ThrowsOnNullTask() - { - // Arrange - await CreateMcpClientForServer(); - - // Act & Assert - await Assert.ThrowsAsync( - () => Server.NotifyTaskStatusAsync(null!, TestContext.Current.CancellationToken)); - } - - [Fact] - public async Task NotifyTaskStatusAsync_SendsMultipleNotificationsForDifferentStatuses() - { - // Arrange - var client = await CreateMcpClientForServer(); - var receivedNotifications = new ConcurrentBag(); - int expectedCount = 3; - var allReceivedTcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - - await using var registration = client.RegisterNotificationHandler( - NotificationMethods.TaskStatusNotification, - (notification, cancellationToken) => - { - if (notification.Params is { } paramsNode) - { - var notificationParams = JsonSerializer.Deserialize(paramsNode, McpJsonUtilities.DefaultOptions); - if (notificationParams is not null) - { - receivedNotifications.Add(notificationParams); - if (receivedNotifications.Count >= expectedCount) - { - allReceivedTcs.TrySetResult(true); - } - } - } - return default; - }); - - // Act - Send notifications for different statuses - var task1 = new McpTask - { - TaskId = "task-456", - Status = McpTaskStatus.Working, - StatusMessage = "Starting", - CreatedAt = DateTimeOffset.UtcNow.AddMinutes(-1), - LastUpdatedAt = DateTimeOffset.UtcNow, - TimeToLive = TimeSpan.FromMinutes(10), - PollInterval = TimeSpan.FromSeconds(1) - }; - - var task2 = new McpTask - { - TaskId = "task-456", - Status = McpTaskStatus.Working, - StatusMessage = "Processing", - CreatedAt = task1.CreatedAt, - LastUpdatedAt = DateTimeOffset.UtcNow, - TimeToLive = TimeSpan.FromMinutes(10), - PollInterval = TimeSpan.FromSeconds(1) - }; - - var task3 = new McpTask - { - TaskId = "task-456", - Status = McpTaskStatus.Completed, - StatusMessage = "Done", - CreatedAt = task1.CreatedAt, - LastUpdatedAt = DateTimeOffset.UtcNow, - TimeToLive = TimeSpan.FromMinutes(10), - PollInterval = TimeSpan.FromSeconds(1) - }; - - await Server.NotifyTaskStatusAsync(task1, TestContext.Current.CancellationToken); - await Server.NotifyTaskStatusAsync(task2, TestContext.Current.CancellationToken); - await Server.NotifyTaskStatusAsync(task3, TestContext.Current.CancellationToken); - - // Wait for all notifications to be received - await allReceivedTcs.Task.WaitAsync(TestContext.Current.CancellationToken); - - // Assert - Assert.Equal(3, receivedNotifications.Count); - Assert.Contains(receivedNotifications, n => n.Status == McpTaskStatus.Working && n.StatusMessage == "Starting"); - Assert.Contains(receivedNotifications, n => n.Status == McpTaskStatus.Working && n.StatusMessage == "Processing"); - Assert.Contains(receivedNotifications, n => n.Status == McpTaskStatus.Completed && n.StatusMessage == "Done"); - } -} diff --git a/tests/ModelContextProtocol.Tests/Server/McpServerTaskTests.cs b/tests/ModelContextProtocol.Tests/Server/McpServerTaskTests.cs new file mode 100644 index 000000000..669499c12 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/McpServerTaskTests.cs @@ -0,0 +1,722 @@ +using ModelContextProtocol.Extensions.Tasks; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using Microsoft.Extensions.DependencyInjection; +using System.Runtime.InteropServices; +using System.Text.Json; +using System.Text.Json.Nodes; + +#pragma warning disable MCPEXP001, MCPEXP002 + +namespace ModelContextProtocol.Tests.Server; + +/// +/// Tests for the MCP tasks extension (SEP-2663) end-to-end using a simple in-memory task store. +/// +public class McpServerTaskTests : ClientServerTestBase +{ + private readonly InMemoryTaskStore _taskStore = new(); + private JsonObject? _capturedMeta; + + public McpServerTaskTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) + { +#if !NET + Assert.SkipWhen(RuntimeInformation.IsOSPlatform(OSPlatform.Windows), "https://github.com/modelcontextprotocol/csharp-sdk/issues/587"); +#endif + } + + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + services.AddSingleton(_taskStore); + + mcpServerBuilder.Services.Configure(options => + { + options.Capabilities ??= new ServerCapabilities(); + options.Capabilities.Extensions ??= new Dictionary(); + options.Capabilities.Extensions[TasksProtocol.ExtensionId] = new JsonObject(); + options.RequestHandlers ??= new List(); + + options.Handlers.CallToolWithAlternateHandler = (context, cancellationToken) => + { + _capturedMeta = context.Params?.Meta; + var store = context.Server.Services!.GetRequiredService(); + var toolName = context.Params!.Name; + + ResultOrAlternate result = toolName switch + { + "immediate-tool" => new(new CallToolResult + { + Content = [new TextContentBlock { Text = "immediate result" }], + }), + "async-tool" => ResultOrAlternate.FromAlternate( + new CreateTaskResult + { + TaskId = store.CreateTask(), + Status = McpTaskStatus.Working, + CreatedAt = DateTimeOffset.UtcNow, + LastUpdatedAt = DateTimeOffset.UtcNow, + PollIntervalMs = 50, + ResultType = "task", + }, + McpTasksJsonContext.Default.CreateTaskResult), + "input-required-tool" => ResultOrAlternate.FromAlternate( + new CreateTaskResult + { + TaskId = store.CreateTask(McpTaskStatus.InputRequired), + Status = McpTaskStatus.InputRequired, + CreatedAt = DateTimeOffset.UtcNow, + LastUpdatedAt = DateTimeOffset.UtcNow, + PollIntervalMs = 50, + ResultType = "task", + }, + McpTasksJsonContext.Default.CreateTaskResult), + _ => throw new McpException($"Unknown tool: {toolName}"), + }; + + return new ValueTask>(result); + }; + + options.RequestHandlers.Add(new McpServerRequestHandler + { + Method = TasksProtocol.MethodTasksGet, + Handler = (request, cancellationToken) => + { + var requestParams = JsonSerializer.Deserialize(request.Params, McpTasksJsonContext.Default.Options) + ?? throw new McpProtocolException("Missing params for tasks/get", McpErrorCode.InvalidParams); + + GetTaskResult result; + try + { + result = _taskStore.GetTask(requestParams.TaskId); + } + catch (McpException ex) + { + throw new McpProtocolException(ex.Message, McpErrorCode.InvalidParams); + } + + return new ValueTask(JsonSerializer.SerializeToNode(result, McpTasksJsonContext.Default.Options)); + }, + }); + + options.RequestHandlers.Add(new McpServerRequestHandler + { + Method = TasksProtocol.MethodTasksUpdate, + Handler = (request, cancellationToken) => + { + var requestParams = JsonSerializer.Deserialize(request.Params, McpTasksJsonContext.Default.Options) + ?? throw new McpProtocolException("Missing params for tasks/update", McpErrorCode.InvalidParams); + + _taskStore.ProvideInput(requestParams.TaskId, requestParams.InputResponses ?? new Dictionary()); + return new ValueTask(JsonSerializer.SerializeToNode(new UpdateTaskResult(), McpTasksJsonContext.Default.Options)); + }, + }); + + options.RequestHandlers.Add(new McpServerRequestHandler + { + Method = TasksProtocol.MethodTasksCancel, + Handler = (request, cancellationToken) => + { + var requestParams = JsonSerializer.Deserialize(request.Params, McpTasksJsonContext.Default.Options) + ?? throw new McpProtocolException("Missing params for tasks/cancel", McpErrorCode.InvalidParams); + + _taskStore.CancelTask(requestParams.TaskId); + return new ValueTask(JsonSerializer.SerializeToNode(new CancelTaskResult(), McpTasksJsonContext.Default.Options)); + }, + }); + }); + } + + [Fact] + public async Task CallToolAsync_ImmediateResult_ReturnsDirectly() + { + await using var client = await CreateMcpClientForServer(); + + var result = await client.CallToolWithPollingAsync( + new CallToolRequestParams { Name = "immediate-tool" }, + cancellationToken: TestContext.Current.CancellationToken); + + Assert.NotNull(result); + Assert.Single(result.Content); + Assert.Equal("immediate result", Assert.IsType(result.Content[0]).Text); + } + + [Fact] + public async Task CallToolAsTaskAsync_ImmediateResult_ReturnsResultNotTask() + { + await using var client = await CreateMcpClientForServer(); + + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "immediate-tool" }, + TestContext.Current.CancellationToken); + + Assert.False(augmented.IsTask); + Assert.NotNull(augmented.Result); + Assert.Null(augmented.TaskCreated); + Assert.Equal("immediate result", Assert.IsType(augmented.Result.Content[0]).Text); + } + + [Fact] + public async Task CallToolAsTaskAsync_AsyncTool_ReturnsTaskCreated() + { + await using var client = await CreateMcpClientForServer(); + + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "async-tool" }, + TestContext.Current.CancellationToken); + + Assert.True(augmented.IsTask); + Assert.NotNull(augmented.TaskCreated); + Assert.Null(augmented.Result); + Assert.Equal(McpTaskStatus.Working, augmented.TaskCreated.Status); + Assert.Equal("task", augmented.TaskCreated.ResultType); + } + + [Fact] + public async Task CallToolAsync_AsyncTool_PollsUntilCompleted() + { + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; + + // Complete the task after a brief delay so polling finds it. + _ = Task.Run(async () => + { + await Task.Delay(100, cancellationToken: ct); + // The store should have exactly one task by now + var taskId = _taskStore.GetAllTaskIds().Single(); + _taskStore.CompleteTask(taskId, new CallToolResult + { + Content = [new TextContentBlock { Text = "async result" }], + }); + }, ct); + + var result = await client.CallToolWithPollingAsync( + new CallToolRequestParams { Name = "async-tool" }, cancellationToken: ct); + + Assert.NotNull(result); + Assert.Single(result.Content); + Assert.Equal("async result", Assert.IsType(result.Content[0]).Text); + } + + [Fact] + public async Task CallToolAsync_AsyncTool_FailedTask_ThrowsMcpException() + { + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; + + var failedTask = new TaskCompletionSource(); + + // Run failure task once the task from the tool call is created + _taskStore.OnTaskCreated += taskId => + { + _ = Task.Run(async () => + { + await Task.Delay(100, ct); + _taskStore.FailTask(taskId, JsonElement.Parse("""{"code":-32000,"message":"something went wrong"}""")); + failedTask.SetResult(true); + }, ct); + }; + + await Assert.ThrowsAsync(async () => + await client.CallToolWithPollingAsync( + new CallToolRequestParams { Name = "async-tool" }, cancellationToken: ct)); + + Assert.True(await failedTask.Task); + } + + [Fact] + public async Task CallToolAsync_AsyncTool_CancelledTask_ThrowsOperationCancelled() + { + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; + + var cancelledTask = new TaskCompletionSource(); + + // Run cancellation task once the task from the tool call is created + _taskStore.OnTaskCreated += taskId => + { + Task.Run(async () => + { + await Task.Delay(100, ct); + _taskStore.CancelTask(taskId); + cancelledTask.SetResult(true); + }, ct); + }; + + await Assert.ThrowsAsync(async () => + await client.CallToolWithPollingAsync( + new CallToolRequestParams { Name = "async-tool" }, cancellationToken: ct)); + + Assert.True(await cancelledTask.Task); + } + + [Fact] + public async Task GetTaskAsync_ReturnsCurrentState() + { + await using var client = await CreateMcpClientForServer(); + + // Create a task via CallToolAsTaskAsync + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "async-tool" }, + cancellationToken: TestContext.Current.CancellationToken); + + var taskId = augmented.TaskCreated!.TaskId; + + // Should be working + var taskResult = await client.GetTaskAsync(taskId, TestContext.Current.CancellationToken); + Assert.IsType(taskResult); + Assert.Equal(taskId, taskResult.TaskId); + Assert.Equal(McpTaskStatus.Working, taskResult.Status); + } + + [Fact] + public async Task CancelTaskAsync_CancelsTask() + { + await using var client = await CreateMcpClientForServer(); + + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "async-tool" }, + TestContext.Current.CancellationToken); + + var taskId = augmented.TaskCreated!.TaskId; + + // Cancel via client + var cancelResult = await client.CancelTaskAsync(taskId, TestContext.Current.CancellationToken); + Assert.NotNull(cancelResult); + + // Verify state changed + var taskResult = await client.GetTaskAsync(taskId, TestContext.Current.CancellationToken); + Assert.IsType(taskResult); + } + + [Fact] + public async Task ConfigureTasks_AdvertisesExtensionInCapabilities() + { + await using var client = await CreateMcpClientForServer(); + + // The server advertises the tasks extension during initialize. + // The client should see it in server capabilities after the handshake. + #pragma warning disable MCP_EXTENSIONS + var extensions = client.ServerCapabilities.Extensions; + #pragma warning restore MCP_EXTENSIONS + Assert.NotNull(extensions); + Assert.True(extensions.ContainsKey(TasksProtocol.ExtensionId)); + } + + [Fact] + public async Task CreateTaskResult_HasResultTypeTask() + { + await using var client = await CreateMcpClientForServer(); + + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "async-tool" }, + TestContext.Current.CancellationToken); + + Assert.True(augmented.IsTask); + Assert.Equal("task", augmented.TaskCreated!.ResultType); + } + + [Fact] + public async Task GetTaskAsync_ImmediatelyAfterCreate_Resolves() + { + // Strong consistency: tasks/get immediately after CreateTaskResult must resolve. + await using var client = await CreateMcpClientForServer(); + + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "async-tool" }, + TestContext.Current.CancellationToken); + + var taskId = augmented.TaskCreated!.TaskId; + + // No delay — immediate get + var taskResult = await client.GetTaskAsync(taskId, TestContext.Current.CancellationToken); + Assert.NotNull(taskResult); + Assert.Equal(taskId, taskResult.TaskId); + } + + [Fact] + public async Task GetTaskAsync_UnknownTaskId_ThrowsWithInvalidParams() + { + await using var client = await CreateMcpClientForServer(); + + var ex = await Assert.ThrowsAsync(async () => + await client.GetTaskAsync("nonexistent-task-id-12345", TestContext.Current.CancellationToken)); + + // The server should reject with an error referencing the unknown task + Assert.Contains("Unknown task", ex.Message); + } + + [Fact] + public async Task CancelTask_AlreadyTerminal_AcknowledgesIdempotently() + { + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; + + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "async-tool" }, ct); + var taskId = augmented.TaskCreated!.TaskId; + + // Cancel once + await client.CancelTaskAsync(taskId, ct); + + // Cancel again on terminal task — should not throw, returns ack + var ack = await client.CancelTaskAsync(taskId, ct); + Assert.NotNull(ack); + } + + [Fact] + public async Task UpdateTaskAsync_TransitionsFromInputRequired() + { + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; + + // Create an input-required task + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "input-required-tool" }, ct); + + var taskId = augmented.TaskCreated!.TaskId; + + // Verify it's input_required + var taskResult = await client.GetTaskAsync(taskId, ct); + Assert.IsType(taskResult); + + // Provide input + var inputResponses = new Dictionary + { + ["resp-1"] = new InputResponse { RawValue = JsonElement.Parse("""{"answer":"yes"}""") } + }; + await client.UpdateTaskAsync(new UpdateTaskRequestParams + { + TaskId = taskId, + InputResponses = inputResponses, + }, ct); + + // Verify it transitioned back to working + taskResult = await client.GetTaskAsync(taskId, ct); + Assert.IsType(taskResult); + } + + [Fact] + public async Task CallToolAsTaskAsync_InjectsTaskCapabilityInMeta() + { + // Verify the server receives the task extension in _meta by intercepting + // the handler. The CallToolWithAlternateHandler already receives the request, + // so we can observe the meta there. We test the client-side injection indirectly + // by confirming the server returns a task result (which requires the capability signal). + await using var client = await CreateMcpClientForServer(); + + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "async-tool" }, + TestContext.Current.CancellationToken); + + // If the capability wasn't injected, the server couldn't have returned a task + Assert.True(augmented.IsTask); + } + + [Fact] + public async Task CallToolAsTaskAsync_OptIn_UsesSep2575CapabilitiesEnvelope() + { + // SEP-2663 §51: the per-request opt-in is the SEP-2575 capabilities envelope: + // _meta/io.modelcontextprotocol/clientCapabilities/extensions/io.modelcontextprotocol/tasks = {} + // This test pins the literal wire path so future refactors can't regress. + await using var client = await CreateMcpClientForServer(); + + await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "immediate-tool" }, + TestContext.Current.CancellationToken); + + Assert.NotNull(_capturedMeta); + + var caps = Assert.IsType(_capturedMeta!["io.modelcontextprotocol/clientCapabilities"]); + var extensions = Assert.IsType(caps["extensions"]); + Assert.True(extensions.ContainsKey("io.modelcontextprotocol/tasks"), + "Expected _meta to contain io.modelcontextprotocol/clientCapabilities/extensions/io.modelcontextprotocol/tasks (SEP-2575 envelope)."); + + // The opt-in value is an empty object per SEP-2575. + Assert.IsType(extensions["io.modelcontextprotocol/tasks"]); + } + + [Fact] + public async Task CallToolAsTaskAsync_OptIn_PreservesExistingMetaSiblings() + { + // User-supplied _meta entries at the root must not be clobbered, and the SEP-2575 + // envelope must be added alongside them, not in place of them. + await using var client = await CreateMcpClientForServer(); + + var userMeta = new JsonObject + { + ["customKey"] = "customValue", + ["io.modelcontextprotocol/clientCapabilities"] = new JsonObject + { + ["extensions"] = new JsonObject + { + ["some.other/extension"] = new JsonObject(), + }, + }, + }; + + await client.CallToolAsTaskAsync( + new CallToolRequestParams + { + Name = "immediate-tool", + Meta = userMeta, + }, + TestContext.Current.CancellationToken); + + Assert.NotNull(_capturedMeta); + + // User's sibling root entry is preserved. + Assert.Equal("customValue", (string?)_capturedMeta!["customKey"]); + + // User's pre-existing nested extension is preserved next to the tasks opt-in. + var caps = Assert.IsType(_capturedMeta["io.modelcontextprotocol/clientCapabilities"]); + var extensions = Assert.IsType(caps["extensions"]); + Assert.True(extensions.ContainsKey("some.other/extension")); + Assert.True(extensions.ContainsKey("io.modelcontextprotocol/tasks")); + } + + [Fact] + public async Task CallToolAsTaskAsync_PreservesExistingUserMeta() + { + // Verify that user-supplied meta fields are not clobbered + await using var client = await CreateMcpClientForServer(); + + var userMeta = new JsonObject { ["customKey"] = "customValue" }; + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams + { + Name = "immediate-tool", + Meta = userMeta, + }, + TestContext.Current.CancellationToken); + + // Should still work — the meta was cloned, not destructively modified + Assert.False(augmented.IsTask); + Assert.Equal("immediate result", Assert.IsType(augmented.Result!.Content[0]).Text); + + // Original user meta should not be mutated + Assert.Single(userMeta); + Assert.Equal("customValue", (string)userMeta["customKey"]!); + } + + [Fact] + public async Task CallToolAsync_RespectsServerPollInterval() + { + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; + + var startTime = DateTime.UtcNow; + + // Complete the task after a brief delay + _ = Task.Run(async () => + { + await Task.Delay(200, ct); + var taskId = _taskStore.GetAllTaskIds().Single(); + _taskStore.CompleteTask(taskId, new CallToolResult + { + Content = [new TextContentBlock { Text = "polled" }], + }); + }, ct); + + var result = await client.CallToolWithPollingAsync( + new CallToolRequestParams { Name = "async-tool" }, cancellationToken: ct); + + var elapsed = DateTime.UtcNow - startTime; + + // The server sets pollIntervalMs=50. The task completes after 200ms. + // So we expect at least 1 poll interval to have passed. + Assert.True(elapsed.TotalMilliseconds >= 50, $"Expected at least 50ms, got {elapsed.TotalMilliseconds}ms"); + Assert.Equal("polled", Assert.IsType(result.Content[0]).Text); + } + + [Fact] + public async Task CallToolWithAlternateHandler_ImplicitConversion_ReturnCallToolResult() + { + // Verify that the implicit conversion from CallToolResult to ResultOrAlternate works + // in the handler context — this is already tested by "immediate-tool" working correctly. + await using var client = await CreateMcpClientForServer(); + + var result = await client.CallToolWithPollingAsync( + new CallToolRequestParams { Name = "immediate-tool" }, + cancellationToken: TestContext.Current.CancellationToken); + + Assert.Equal("immediate result", Assert.IsType(result.Content[0]).Text); + } + + [Fact] + public async Task CallToolHandler_And_CallToolWithAlternateHandler_AreMutuallyExclusive() + { + var handlers = new McpServerHandlers(); + + handlers.CallToolWithAlternateHandler = async (ctx, ct) => new CallToolResult(); + Assert.Throws(() => + handlers.CallToolHandler = async (ctx, ct) => new CallToolResult()); + + handlers = new McpServerHandlers(); + + handlers.CallToolHandler = async (ctx, ct) => new CallToolResult(); + Assert.Throws(() => + handlers.CallToolWithAlternateHandler = async (ctx, ct) => new CallToolResult()); + } + + [Fact] + public async Task CallToolHandler_CanBeSetToNull_ThenOtherCanBeSet() + { + var handlers = new McpServerHandlers(); + + handlers.CallToolHandler = async (ctx, ct) => new CallToolResult(); + handlers.CallToolHandler = null; + + // Now setting the other should work + handlers.CallToolWithAlternateHandler = async (ctx, ct) => new CallToolResult(); + Assert.NotNull(handlers.CallToolWithAlternateHandler); + } + + /// + /// Simple in-memory task store for testing. + /// + private sealed class InMemoryTaskStore + { + private readonly Dictionary _tasks = new(); + + internal Action? OnTaskCreated; + + public string CreateTask(McpTaskStatus initialStatus = McpTaskStatus.Working) + { + var taskId = Guid.NewGuid().ToString("N"); + lock (_tasks) + { + _tasks[taskId] = new TaskEntry + { + Status = initialStatus, + CreatedAt = DateTimeOffset.UtcNow, + LastUpdatedAt = DateTimeOffset.UtcNow, + }; + } + + OnTaskCreated?.Invoke(taskId); + + return taskId; + } + + public IEnumerable GetAllTaskIds() + { + lock (_tasks) + { + return _tasks.Keys.ToArray(); + } + } + + public GetTaskResult GetTask(string taskId) + { + lock (_tasks) + { + if (!_tasks.TryGetValue(taskId, out var entry)) + { + throw new McpException($"Unknown task: '{taskId}'"); + } + + return entry.Status switch + { + McpTaskStatus.Working => new WorkingTaskResult + { + TaskId = taskId, + CreatedAt = entry.CreatedAt, + LastUpdatedAt = entry.LastUpdatedAt, + PollIntervalMs = 50, + }, + McpTaskStatus.Completed => new CompletedTaskResult + { + TaskId = taskId, + CreatedAt = entry.CreatedAt, + LastUpdatedAt = entry.LastUpdatedAt, + Result = JsonSerializer.SerializeToElement(entry.Result, McpJsonUtilities.DefaultOptions), + }, + McpTaskStatus.Failed => new FailedTaskResult + { + TaskId = taskId, + CreatedAt = entry.CreatedAt, + LastUpdatedAt = entry.LastUpdatedAt, + Error = entry.Error!.Value, + }, + McpTaskStatus.Cancelled => new CancelledTaskResult + { + TaskId = taskId, + CreatedAt = entry.CreatedAt, + LastUpdatedAt = entry.LastUpdatedAt, + }, + McpTaskStatus.InputRequired => new InputRequiredTaskResult + { + TaskId = taskId, + CreatedAt = entry.CreatedAt, + LastUpdatedAt = entry.LastUpdatedAt, + InputRequests = entry.InputRequests ?? new Dictionary(), + }, + _ => throw new InvalidOperationException($"Unexpected status: {entry.Status}") + }; + } + } + + public void CompleteTask(string taskId, CallToolResult result) + { + lock (_tasks) + { + if (_tasks.TryGetValue(taskId, out var entry)) + { + entry.Result = result; + entry.LastUpdatedAt = DateTimeOffset.UtcNow; + entry.Status = McpTaskStatus.Completed; + } + } + } + + public void FailTask(string taskId, JsonElement error) + { + lock (_tasks) + { + if (_tasks.TryGetValue(taskId, out var entry)) + { + entry.Error = error; + entry.LastUpdatedAt = DateTimeOffset.UtcNow; + entry.Status = McpTaskStatus.Failed; + } + } + } + + public void CancelTask(string taskId) + { + lock (_tasks) + { + if (_tasks.TryGetValue(taskId, out var entry)) + { + entry.LastUpdatedAt = DateTimeOffset.UtcNow; + entry.Status = McpTaskStatus.Cancelled; + } + } + } + + public void ProvideInput(string taskId, IDictionary inputResponses) + { + lock (_tasks) + { + if (_tasks.TryGetValue(taskId, out var entry)) + { + entry.InputResponses = inputResponses; + entry.LastUpdatedAt = DateTimeOffset.UtcNow; + // Transition back to working after receiving input + entry.Status = McpTaskStatus.Working; + } + } + } + + private sealed class TaskEntry + { + public McpTaskStatus Status { get; set; } + public DateTimeOffset CreatedAt { get; set; } + public DateTimeOffset LastUpdatedAt { get; set; } + public CallToolResult? Result { get; set; } + public JsonElement? Error { get; set; } + public IDictionary? InputRequests { get; set; } + public IDictionary? InputResponses { get; set; } + } + } +} diff --git a/tests/ModelContextProtocol.Tests/Server/McpServerTasksNoStoreTests.cs b/tests/ModelContextProtocol.Tests/Server/McpServerTasksNoStoreTests.cs new file mode 100644 index 000000000..db051d19f --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/McpServerTasksNoStoreTests.cs @@ -0,0 +1,71 @@ +using ModelContextProtocol.Extensions.Tasks; +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.Runtime.InteropServices; + +#pragma warning disable MCPEXP001 + +namespace ModelContextProtocol.Tests.Server; + +/// +/// Pins the behavior when a client signals the SEP-2575 tasks opt-in via _meta but the server +/// has neither nor a +/// configured. The expected behavior is a silent synchronous fallback: the server returns the normal +/// with no Task envelope and no exception. +/// +public class McpServerTasksNoStoreTests : ClientServerTestBase +{ + public McpServerTasksNoStoreTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) + { +#if !NET + Assert.SkipWhen(RuntimeInformation.IsOSPlatform(OSPlatform.Windows), "https://github.com/modelcontextprotocol/csharp-sdk/issues/587"); +#endif + } + + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + // Intentionally do NOT configure TaskStore or CallToolWithAlternateHandler. + mcpServerBuilder.WithTools(); + } + + [Fact] + public async Task ClientOptIn_NoTaskStore_FallsBackToSyncResult() + { + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; + + // CallToolAsTaskAsync always writes the SEP-2575 tasks opt-in into _meta. + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "sync-tool" }, ct); + + // With no task store configured, the server must complete synchronously and return + // the standard CallToolResult — not a task envelope. + Assert.False(augmented.IsTask); + Assert.NotNull(augmented.Result); + Assert.Equal("sync result", Assert.IsType(augmented.Result!.Content[0]).Text); + } + + [Fact] + public async Task ClientOptIn_NoTaskStore_CallToolAsync_StillReturnsResult() + { + // CallToolAsync (the higher-level convenience) must also work in the no-store case, + // delegating to the underlying sync path without throwing. + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; + + var result = await client.CallToolWithPollingAsync( + new CallToolRequestParams { Name = "sync-tool" }, cancellationToken: ct); + + Assert.NotNull(result); + Assert.Equal("sync result", Assert.IsType(result.Content[0]).Text); + } + + [McpServerToolType] + private sealed class NoStoreTools + { + [McpServerTool(Name = "sync-tool"), System.ComponentModel.Description("A plain sync tool")] + public static string SyncTool() => "sync result"; + } +} diff --git a/tests/ModelContextProtocol.Tests/Server/McpServerTests.cs b/tests/ModelContextProtocol.Tests/Server/McpServerTests.cs index d9febd721..e54f40dcb 100644 --- a/tests/ModelContextProtocol.Tests/Server/McpServerTests.cs +++ b/tests/ModelContextProtocol.Tests/Server/McpServerTests.cs @@ -4,6 +4,7 @@ using ModelContextProtocol.Tests.Utils; using System.Reflection; using System.Runtime.InteropServices; +using System.Text; using System.Text.Json; using System.Text.Json.Nodes; @@ -26,7 +27,7 @@ private static McpServerOptions CreateOptions(ServerCapabilities? capabilities = { return new McpServerOptions { - ProtocolVersion = "2024", + ProtocolVersion = "2024-11-05", InitializationTimeout = TimeSpan.FromSeconds(30), Capabilities = capabilities, }; @@ -283,13 +284,95 @@ await Can_Handle_Requests( { var result = JsonSerializer.Deserialize(response, McpJsonUtilities.DefaultOptions); Assert.NotNull(result); + Assert.Null(result.ResultType); Assert.Equal(expectedAssemblyName.Name, result.ServerInfo.Name); Assert.Equal(expectedAssemblyName.Version?.ToString() ?? "1.0.0", result.ServerInfo.Version); - Assert.Equal("2024", result.ProtocolVersion); - Assert.Equal("2024", server.NegotiatedProtocolVersion); + Assert.Equal("2024-11-05", result.ProtocolVersion); + Assert.Equal("2024-11-05", server.NegotiatedProtocolVersion); }); } + [Fact] + public async Task RejectedReservedPerRequestMetadata_DoesNotEstablishProtocolVersion() + { + var ct = TestContext.Current.CancellationToken; + await using var transport = new TestServerTransport(); + var options = CreateOptions(); + options.ProtocolVersion = null; + + await using var server = McpServer.Create(transport, options, LoggerFactory); + var runTask = server.RunAsync(ct); + + var rejectedResponse = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + var acceptedResponse = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + transport.OnMessageSent = message => + { + if (message is JsonRpcError { Id: var errorId } error && errorId.ToString() == "1") + { + rejectedResponse.TrySetResult(error); + } + else if (message is JsonRpcMessageWithId { Id: var responseId } && responseId.ToString() == "2") + { + acceptedResponse.TrySetResult(message); + } + }; + + await transport.SendClientMessageAsync(new JsonRpcRequest + { + Id = new RequestId(1), + Method = RequestMethods.ToolsList, + Params = new JsonObject + { + ["_meta"] = new JsonObject + { + [MetaKeys.ClientInfo] = new JsonObject + { + ["name"] = "test-client", + ["version"] = "1.0.0", + }, + }, + }, + Context = new JsonRpcMessageContext + { + ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion, + ClientInfo = new Implementation { Name = "test-client", Version = "1.0.0" }, + }, + }, ct); + + var error = await rejectedResponse.Task.WaitAsync(TestConstants.DefaultTimeout, ct); + Assert.Equal((int)McpErrorCode.InvalidRequest, error.Error.Code); + Assert.Null(server.NegotiatedProtocolVersion); + + var clientInfo = new Implementation { Name = "test-client", Version = "1.0.0" }; + var clientCapabilities = new ClientCapabilities(); + await transport.SendClientMessageAsync(new JsonRpcRequest + { + Id = new RequestId(2), + Method = RequestMethods.ToolsList, + Params = new JsonObject + { + ["_meta"] = new JsonObject + { + [MetaKeys.ProtocolVersion] = McpProtocolVersions.July2026ProtocolVersion, + [MetaKeys.ClientInfo] = JsonSerializer.SerializeToNode(clientInfo, McpJsonUtilities.DefaultOptions), + [MetaKeys.ClientCapabilities] = new JsonObject(), + }, + }, + Context = new JsonRpcMessageContext + { + ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion, + ClientInfo = clientInfo, + ClientCapabilities = clientCapabilities, + }, + }, ct); + + await acceptedResponse.Task.WaitAsync(TestConstants.DefaultTimeout, ct); + Assert.Equal(McpProtocolVersions.July2026ProtocolVersion, server.NegotiatedProtocolVersion); + + await transport.DisposeAsync(); + await runTask; + } + [Fact] public async Task Initialize_IncludesExtensionsInResponse() { @@ -304,6 +387,7 @@ await Can_Handle_Requests( { var result = JsonSerializer.Deserialize(response, McpJsonUtilities.DefaultOptions); Assert.NotNull(result); + Assert.Null(result.ResultType); Assert.NotNull(result.Capabilities.Extensions); Assert.True(result.Capabilities.Extensions.ContainsKey("io.myext")); }); @@ -323,6 +407,7 @@ await Can_Handle_Requests( { var result = JsonSerializer.Deserialize(response, McpJsonUtilities.DefaultOptions); Assert.NotNull(result); + Assert.Null(result.ResultType); Assert.NotNull(result.Capabilities.Experimental); Assert.True(result.Capabilities.Experimental.ContainsKey("customFeature")); }); @@ -343,22 +428,18 @@ public async Task Initialize_CopiesAllCapabilityProperties() Resources = new ResourcesCapability(), Tools = new ToolsCapability(), Completions = new CompletionsCapability(), - Tasks = new McpTasksCapability(), Extensions = new Dictionary { ["io.test"] = new JsonObject() }, }; await Can_Handle_Requests( serverCapabilities: inputCapabilities, method: RequestMethods.Initialize, - configureOptions: options => - { - // Tasks capability requires a TaskStore - options.TaskStore = new InMemoryMcpTaskStore(); - }, + configureOptions: _ => { }, assertResult: (_, response) => { var result = JsonSerializer.Deserialize(response, McpJsonUtilities.DefaultOptions); Assert.NotNull(result); + Assert.Null(result.ResultType); // Use reflection to verify every public property on ServerCapabilities is non-null. // This catches cases where new capability properties are added but not copied @@ -405,6 +486,7 @@ await Can_Handle_Requests( { var result = JsonSerializer.Deserialize(response, McpJsonUtilities.DefaultOptions); Assert.NotNull(result?.Completion); + Assert.Null(result.ResultType); Assert.Equal(["test"], result.Completion.Values); Assert.Equal(2, result.Completion.Total); Assert.True(result.Completion.HasMore); @@ -448,6 +530,7 @@ await transport.SendMessageAsync(new JsonRpcRequest Assert.NotNull(response); var result = JsonSerializer.Deserialize(response.Result, McpJsonUtilities.DefaultOptions); Assert.NotNull(result?.Completion); + Assert.Null(result.ResultType); Assert.Equal(["cat"], result.Completion.Values); Assert.Equal(1, result.Completion.Total); @@ -491,6 +574,7 @@ await transport.SendMessageAsync(new JsonRpcRequest Assert.NotNull(response); var result = JsonSerializer.Deserialize(response.Result, McpJsonUtilities.DefaultOptions); Assert.NotNull(result?.Completion); + Assert.Null(result.ResultType); Assert.Empty(result.Completion.Values); await transport.DisposeAsync(); @@ -540,6 +624,7 @@ await transport.SendMessageAsync(new JsonRpcRequest Assert.NotNull(response); var result = JsonSerializer.Deserialize(response.Result, McpJsonUtilities.DefaultOptions); Assert.NotNull(result?.Completion); + Assert.Null(result.ResultType); Assert.Equal(["us-east-1", "us-west-2"], result.Completion.Values); Assert.Equal(2, result.Completion.Total); @@ -595,6 +680,7 @@ await transport.SendMessageAsync(new JsonRpcRequest Assert.NotNull(response); var result = JsonSerializer.Deserialize(response.Result, McpJsonUtilities.DefaultOptions); Assert.NotNull(result?.Completion); + Assert.Null(result.ResultType); // Custom handler values + auto-populated values should be combined Assert.Equal(["custom-value", "dog", "cat"], result.Completion.Values); Assert.Equal(3, result.Completion.Total); @@ -642,6 +728,7 @@ await transport.SendMessageAsync(new JsonRpcRequest Assert.NotNull(response); var result = JsonSerializer.Deserialize(response.Result, McpJsonUtilities.DefaultOptions); Assert.NotNull(result?.Completion); + Assert.Null(result.ResultType); Assert.Equal(["a", "b"], result.Completion.Values); await transport.DisposeAsync(); @@ -680,6 +767,7 @@ await Can_Handle_Requests( { var result = JsonSerializer.Deserialize(response, McpJsonUtilities.DefaultOptions); Assert.NotNull(result?.ResourceTemplates); + Assert.Null(result.ResultType); Assert.NotEmpty(result.ResourceTemplates); Assert.Equal("test", result.ResourceTemplates[0].UriTemplate); }); @@ -709,6 +797,7 @@ await Can_Handle_Requests( { var result = JsonSerializer.Deserialize(response, McpJsonUtilities.DefaultOptions); Assert.NotNull(result?.Resources); + Assert.Null(result.ResultType); Assert.NotEmpty(result.Resources); Assert.Equal("test", result.Resources[0].Uri); }); @@ -744,6 +833,7 @@ await Can_Handle_Requests( { var result = JsonSerializer.Deserialize(response, McpJsonUtilities.DefaultOptions); Assert.NotNull(result?.Contents); + Assert.Null(result.ResultType); Assert.NotEmpty(result.Contents); TextResourceContents textResource = Assert.IsType(result.Contents[0]); @@ -781,6 +871,7 @@ await Can_Handle_Requests( { var result = JsonSerializer.Deserialize(response, McpJsonUtilities.DefaultOptions); Assert.NotNull(result?.Prompts); + Assert.Null(result.ResultType); Assert.NotEmpty(result.Prompts); Assert.Equal("test", result.Prompts[0].Name); }); @@ -810,6 +901,7 @@ await Can_Handle_Requests( { var result = JsonSerializer.Deserialize(response, McpJsonUtilities.DefaultOptions); Assert.NotNull(result); + Assert.Null(result.ResultType); Assert.Equal("test", result.Description); }); } @@ -844,6 +936,7 @@ await Can_Handle_Requests( { var result = JsonSerializer.Deserialize(response, McpJsonUtilities.DefaultOptions); Assert.NotNull(result); + Assert.Null(result.ResultType); Assert.NotEmpty(result.Tools); Assert.Equal("test", result.Tools[0].Name); }); @@ -879,17 +972,149 @@ await Can_Handle_Requests( { var result = JsonSerializer.Deserialize(response, McpJsonUtilities.DefaultOptions); Assert.NotNull(result); + Assert.Null(result.ResultType); Assert.NotEmpty(result.Content); Assert.Equal("test", Assert.IsType(result.Content[0]).Text); }); } + [Fact] + public async Task Can_Handle_Call_Tool_Requests_With_Embedded_Pdf_Resource_On_Wire() + { + byte[] pdfBytes = Encoding.ASCII.GetBytes("%PDF-1.7\n"); + await using var transport = new TestServerTransport(); + var options = CreateOptions(new ServerCapabilities { Tools = new() }); + options.Handlers.CallToolHandler = async (request, ct) => + { + return new CallToolResult + { + Content = + [ + new EmbeddedResourceBlock + { + Resource = BlobResourceContents.FromBytes( + pdfBytes, + "file:///mypdf.pdf", + "application/pdf") + } + ] + }; + }; + options.Handlers.ListToolsHandler = (request, ct) => throw new NotImplementedException(); + + await using var server = McpServer.Create(transport, options, LoggerFactory); + var runTask = server.RunAsync(TestContext.Current.CancellationToken); + var receivedMessage = new TaskCompletionSource(); + + transport.OnMessageSent = message => + { + if (message is JsonRpcResponse response && response.Id.ToString() == "55") + { + receivedMessage.SetResult(response); + } + }; + + await transport.SendMessageAsync( + new JsonRpcRequest + { + Method = RequestMethods.ToolsCall, + Id = new RequestId(55) + }, + TestContext.Current.CancellationToken); + + var response = await receivedMessage.Task.WaitAsync( + TestConstants.DefaultTimeout, + TestContext.Current.CancellationToken); + string wireJson = JsonSerializer.Serialize( + response, + McpJsonUtilities.DefaultOptions); + + using JsonDocument document = JsonDocument.Parse(wireJson); + JsonElement root = document.RootElement; + Assert.Equal("2.0", root.GetProperty("jsonrpc").GetString()); + Assert.Equal(55, root.GetProperty("id").GetInt32()); + + JsonElement resourceBlock = root.GetProperty("result").GetProperty("content")[0]; + Assert.Equal("resource", resourceBlock.GetProperty("type").GetString()); + JsonElement resource = resourceBlock.GetProperty("resource"); + Assert.Equal("file:///mypdf.pdf", resource.GetProperty("uri").GetString()); + Assert.Equal("application/pdf", resource.GetProperty("mimeType").GetString()); + Assert.Equal(Convert.ToBase64String(pdfBytes), resource.GetProperty("blob").GetString()); + + var roundTrippedMessage = JsonSerializer.Deserialize( + wireJson, + McpJsonUtilities.DefaultOptions); + var roundTrippedResponse = Assert.IsType(roundTrippedMessage); + var result = roundTrippedResponse.Result.Deserialize( + McpJsonUtilities.DefaultOptions); + Assert.NotNull(result); + var embeddedResource = Assert.IsType(Assert.Single(result.Content)); + var pdfResource = Assert.IsType(embeddedResource.Resource); + Assert.Equal(pdfBytes, pdfResource.DecodedData.ToArray()); + + await transport.DisposeAsync(); + await runTask; + } + [Fact] public async Task Can_Handle_Call_Tool_Requests_Throws_Exception_If_No_Handler_Assigned() { await Succeeds_Even_If_No_Handler_Assigned(new ServerCapabilities { Tools = new() }, RequestMethods.ToolsCall, "CallTool handler not configured"); } + [Fact] + public async Task Can_Handle_SetLoggingLevel_Requests() + { + await Can_Handle_Requests( + new ServerCapabilities + { + Logging = new() + }, + method: RequestMethods.LoggingSetLevel, + configureOptions: options => + { + // logging/setLevel is a legacy (2025-06-18) method whose result must serialize as an + // empty object {}. The custom handler returns a bare result and the server must not + // add a resultType, otherwise the MCP conformance suite rejects the response. + options.Handlers.SetLoggingLevelHandler = async (request, ct) => new EmptyResult(); + }, + assertResult: (_, response) => + { + var result = JsonSerializer.Deserialize(response, McpJsonUtilities.DefaultOptions); + Assert.NotNull(result); + Assert.Null(result.ResultType); + + // The wire response must be exactly {} with no additional properties. + var obj = Assert.IsType(response); + Assert.Empty(obj); + }); + } + + [Fact] + public async Task Can_Handle_SetLoggingLevel_Requests_WithoutHandler_OmitsResultType() + { + // With no custom SetLoggingLevelHandler configured, the server uses its default logging/setLevel + // handler. logging/setLevel is a legacy (<= 2025-11-25) method, so the default handler must also + // serialize its result as an empty object {} without the 2026-07-28 resultType field (issue #1721). + await Can_Handle_Requests( + new ServerCapabilities + { + Logging = new() + }, + method: RequestMethods.LoggingSetLevel, + configureOptions: null, + assertResult: (_, response) => + { + var result = JsonSerializer.Deserialize(response, McpJsonUtilities.DefaultOptions); + Assert.NotNull(result); + Assert.Null(result.ResultType); + + // The wire response must be exactly {} with no additional properties. + var obj = Assert.IsType(response); + Assert.Empty(obj); + }); + } + [Fact] public async Task Can_Handle_Call_Tool_Requests_With_McpException() { @@ -912,6 +1137,7 @@ await Can_Handle_Requests( { var result = JsonSerializer.Deserialize(response, McpJsonUtilities.DefaultOptions); Assert.NotNull(result); + Assert.Null(result.ResultType); Assert.True(result.IsError); Assert.NotEmpty(result.Content); var textContent = Assert.IsType(result.Content[0]); @@ -940,6 +1166,7 @@ await Can_Handle_Requests( { var result = JsonSerializer.Deserialize(response, McpJsonUtilities.DefaultOptions); Assert.NotNull(result); + Assert.Null(result.ResultType); Assert.True(result.IsError); Assert.NotEmpty(result.Content); var textContent = Assert.IsType(result.Content[0]); @@ -975,6 +1202,7 @@ await Can_Handle_Requests( { var result = JsonSerializer.Deserialize(response, McpJsonUtilities.DefaultOptions); Assert.NotNull(result); + Assert.Null(result.ResultType); Assert.True(result.IsError, "Input validation errors should be returned as tool execution errors (IsError=true), not protocol errors"); Assert.NotEmpty(result.Content); var textContent = Assert.IsType(result.Content[0]); @@ -1033,7 +1261,7 @@ await transport.SendMessageAsync( public async Task Can_Handle_Call_Tool_Requests_With_McpProtocolException_And_Data() { const string ErrorMessage = "Resource not found"; - const McpErrorCode ErrorCode = McpErrorCode.ResourceNotFound; + const McpErrorCode ErrorCode = McpErrorCode.InvalidParams; const string ResourceUri = "file:///path/to/resource"; await using var transport = new TestServerTransport(); @@ -1235,6 +1463,7 @@ await transport.SendClientMessageAsync(new JsonRpcNotification Assert.NotNull(response.Result); var initResult = JsonSerializer.Deserialize(response.Result, McpJsonUtilities.DefaultOptions); Assert.NotNull(initResult); + Assert.Null(initResult.ResultType); Assert.NotNull(initResult.ServerInfo); await transport.DisposeAsync(); @@ -1373,7 +1602,10 @@ public override Task SendRequestAsync(JsonRpcRequest request, C public override string? NegotiatedProtocolVersion => throw new NotImplementedException(); public override Implementation? ClientInfo => throw new NotImplementedException(); public override IServiceProvider? Services => throw new NotImplementedException(); + // McpServer.LoggingLevel is obsolete (SEP-2577) but abstract, so this test double must override it. +#pragma warning disable CS0672 // Member overrides obsolete member public override LoggingLevel? LoggingLevel => throw new NotImplementedException(); +#pragma warning restore CS0672 public override Task SendMessageAsync(JsonRpcMessage message, CancellationToken cancellationToken = default) => throw new NotImplementedException(); public override Task RunAsync(CancellationToken cancellationToken = default) => diff --git a/tests/ModelContextProtocol.Tests/Server/McpServerToolTests.cs b/tests/ModelContextProtocol.Tests/Server/McpServerToolTests.cs index 808ba7efe..8fd1d9954 100644 --- a/tests/ModelContextProtocol.Tests/Server/McpServerToolTests.cs +++ b/tests/ModelContextProtocol.Tests/Server/McpServerToolTests.cs @@ -461,15 +461,22 @@ public async Task SupportsSchemaCreateOptions() [MemberData(nameof(StructuredOutput_ReturnsExpectedSchema_Inputs))] public async Task StructuredOutput_Enabled_ReturnsExpectedSchema(T value) { + // Per SEP-2106 the output schema's top-level "type" matches the natural shape of the + // return value (e.g. "string", "integer", "array") rather than always being "object". + // The strict round-trip check is AssertMatchesJsonSchema below, which proves the + // emitted structuredContent validates against the published schema. + // + // Pinned to a SEP-2106 negotiated version because the assertion compares the natural + // in-memory schema against the emitted value. Under a legacy negotiated version the + // emitted value would be re-wrapped in {"result": } for backward compatibility + // and would no longer validate against the natural schema. JsonSerializerOptions options = new() { TypeInfoResolver = new DefaultJsonTypeInfoResolver() }; McpServerTool tool = McpServerTool.Create(() => value, new() { Name = "tool", UseStructuredContent = true, SerializerOptions = options }); - var mockServer = new Mock(); - var request = new RequestContext(mockServer.Object, CreateTestJsonRpcRequest(), new CallToolRequestParams { Name = "tool" }); + var request = CreateRequestContextWithProtocolVersion(Sep2106ProtocolVersion); var result = await tool.InvokeAsync(request, TestContext.Current.CancellationToken); Assert.NotNull(tool.ProtocolTool.OutputSchema); - Assert.Equal("object", tool.ProtocolTool.OutputSchema.Value.GetProperty("type").GetString()); Assert.NotNull(result.StructuredContent); AssertMatchesJsonSchema(tool.ProtocolTool.OutputSchema.Value, result.StructuredContent); } @@ -594,9 +601,11 @@ public void OutputSchema_Options_RequiresUseStructuredContent() } [Fact] - public void OutputSchema_Options_NonObjectSchema_GetsWrapped() + public void OutputSchema_Options_NonObjectSchema_PassesThrough() { - // Non-object output schema should be wrapped in a "result" property envelope + // Per SEP-2106, outputSchema may be any valid JSON Schema document — including + // non-object schemas. The SDK no longer wraps non-object schemas in a + // {"type":"object","properties":{"result":}} envelope. JsonElement outputSchema = JsonDocument.Parse("""{"type":"string"}""").RootElement; McpServerTool tool = McpServerTool.Create(() => "result", new() { @@ -605,16 +614,15 @@ public void OutputSchema_Options_NonObjectSchema_GetsWrapped() }); Assert.NotNull(tool.ProtocolTool.OutputSchema); - Assert.Equal("object", tool.ProtocolTool.OutputSchema.Value.GetProperty("type").GetString()); - Assert.True(tool.ProtocolTool.OutputSchema.Value.TryGetProperty("properties", out var properties)); - Assert.True(properties.TryGetProperty("result", out var resultProp)); - Assert.Equal("string", resultProp.GetProperty("type").GetString()); + Assert.Equal("string", tool.ProtocolTool.OutputSchema.Value.GetProperty("type").GetString()); + Assert.False(tool.ProtocolTool.OutputSchema.Value.TryGetProperty("properties", out _)); } [Fact] - public void OutputSchema_Options_NullableObjectSchema_BecomesObject() + public void OutputSchema_Options_NullableObjectSchema_PassesThrough() { - // ["object", "null"] type should be simplified to just "object" + // Per SEP-2106, the SDK no longer normalizes ["object","null"] type-arrays down + // to just "object". The schema author's intent is preserved on the wire. JsonElement outputSchema = JsonDocument.Parse("""{"type":["object","null"],"properties":{"name":{"type":"string"}}}""").RootElement; McpServerTool tool = McpServerTool.Create(() => "result", new() { @@ -623,7 +631,171 @@ public void OutputSchema_Options_NullableObjectSchema_BecomesObject() }); Assert.NotNull(tool.ProtocolTool.OutputSchema); - Assert.Equal("object", tool.ProtocolTool.OutputSchema.Value.GetProperty("type").GetString()); + var typeProperty = tool.ProtocolTool.OutputSchema.Value.GetProperty("type"); + Assert.Equal(JsonValueKind.Array, typeProperty.ValueKind); + Assert.Collection(typeProperty.EnumerateArray(), + t => Assert.Equal("object", t.GetString()), + t => Assert.Equal("null", t.GetString())); + } + + [Fact] + public void OutputSchema_Create_StringReturn_NoEnvelope() + { + // End-to-end check: a tool with a string return type and UseStructuredContent + // produces an outputSchema describing the string directly (no "result" envelope) + // and emits the raw string value as structuredContent. + McpServerTool tool = McpServerTool.Create(() => "hello", new() { UseStructuredContent = true }); + + Assert.NotNull(tool.ProtocolTool.OutputSchema); + Assert.Equal("string", tool.ProtocolTool.OutputSchema.Value.GetProperty("type").GetString()); + Assert.False(tool.ProtocolTool.OutputSchema.Value.TryGetProperty("properties", out _)); + } + + // SEP-2106 backward-compat: for clients negotiating a pre-2026-07-28 protocol version, + // non-object structured content is wrapped in the legacy {"result": } envelope. + // Clients on the SEP-2106 protocol ("2026-07-28" and later) see the + // natural value shape. In-memory storage stays natural in both modes; only the wire + // emission flips. + private const string LegacyProtocolVersion = "2025-11-25"; + private const string Sep2106ProtocolVersion = "2026-07-28"; + + [Theory] + [InlineData(LegacyProtocolVersion, true)] + [InlineData(null, true)] + [InlineData(Sep2106ProtocolVersion, false)] + public async Task StructuredContent_StringReturn_WrapsForLegacyClients(string? protocolVersion, bool expectWrapped) + { + McpServerTool tool = McpServerTool.Create(() => "hello", new() { Name = "tool", UseStructuredContent = true }); + var request = CreateRequestContextWithProtocolVersion(protocolVersion); + + var result = await tool.InvokeAsync(request, TestContext.Current.CancellationToken); + + Assert.NotNull(result.StructuredContent); + if (expectWrapped) + { + Assert.Equal(JsonValueKind.Object, result.StructuredContent.Value.ValueKind); + Assert.True(result.StructuredContent.Value.TryGetProperty("result", out var inner)); + Assert.Equal("hello", inner.GetString()); + } + else + { + Assert.Equal(JsonValueKind.String, result.StructuredContent.Value.ValueKind); + Assert.Equal("hello", result.StructuredContent.Value.GetString()); + } + } + + [Theory] + [InlineData(LegacyProtocolVersion, true)] + [InlineData(null, true)] + [InlineData(Sep2106ProtocolVersion, false)] + public async Task StructuredContent_IntegerReturn_WrapsForLegacyClients(string? protocolVersion, bool expectWrapped) + { + McpServerTool tool = McpServerTool.Create(() => 42, new() { Name = "tool", UseStructuredContent = true }); + var request = CreateRequestContextWithProtocolVersion(protocolVersion); + + var result = await tool.InvokeAsync(request, TestContext.Current.CancellationToken); + + Assert.NotNull(result.StructuredContent); + if (expectWrapped) + { + Assert.Equal(JsonValueKind.Object, result.StructuredContent.Value.ValueKind); + Assert.True(result.StructuredContent.Value.TryGetProperty("result", out var inner)); + Assert.Equal(42, inner.GetInt32()); + } + else + { + Assert.Equal(JsonValueKind.Number, result.StructuredContent.Value.ValueKind); + Assert.Equal(42, result.StructuredContent.Value.GetInt32()); + } + } + + [Theory] + [InlineData(LegacyProtocolVersion, true)] + [InlineData(null, true)] + [InlineData(Sep2106ProtocolVersion, false)] + public async Task StructuredContent_ArrayReturn_WrapsForLegacyClients(string? protocolVersion, bool expectWrapped) + { + McpServerTool tool = McpServerTool.Create(() => new[] { "a", "b" }, new() { Name = "tool", UseStructuredContent = true }); + var request = CreateRequestContextWithProtocolVersion(protocolVersion); + + var result = await tool.InvokeAsync(request, TestContext.Current.CancellationToken); + + Assert.NotNull(result.StructuredContent); + if (expectWrapped) + { + Assert.Equal(JsonValueKind.Object, result.StructuredContent.Value.ValueKind); + Assert.True(result.StructuredContent.Value.TryGetProperty("result", out var inner)); + Assert.Equal(JsonValueKind.Array, inner.ValueKind); + Assert.Equal(2, inner.GetArrayLength()); + } + else + { + Assert.Equal(JsonValueKind.Array, result.StructuredContent.Value.ValueKind); + Assert.Equal(2, result.StructuredContent.Value.GetArrayLength()); + } + } + + [Theory] + [InlineData(LegacyProtocolVersion)] + [InlineData(null)] + [InlineData(Sep2106ProtocolVersion)] + public async Task StructuredContent_ObjectReturn_NeverWrapped(string? protocolVersion) + { + // Object-typed return: the stored schema is type:"object" — already the form + // expected by clients on protocol versions older than 2026-07-28, so no envelope + // is applied at any protocol version. Wire shape must be identical across versions. + McpServerTool tool = McpServerTool.Create(() => new Person("John", 27), new() + { + Name = "tool", + UseStructuredContent = true, + SerializerOptions = CreateSerializerOptionsWithPerson(), + }); + var request = CreateRequestContextWithProtocolVersion(protocolVersion); + + var result = await tool.InvokeAsync(request, TestContext.Current.CancellationToken); + + Assert.NotNull(result.StructuredContent); + Assert.Equal(JsonValueKind.Object, result.StructuredContent.Value.ValueKind); + Assert.False(result.StructuredContent.Value.TryGetProperty("result", out _)); + Assert.Equal("John", result.StructuredContent.Value.GetProperty("name").GetString()); + Assert.Equal(27, result.StructuredContent.Value.GetProperty("age").GetInt32()); + } + + [Theory] + [InlineData(LegacyProtocolVersion)] + [InlineData(null)] + [InlineData(Sep2106ProtocolVersion)] + public async Task StructuredContent_NullableObjectReturn_NeverWrapped(string? protocolVersion) + { + // type:["object","null"]: for clients on protocol versions older than 2026-07-28, + // the SCHEMA is normalized to plain type:"object" (verified in + // Sep2106ListToolsBackCompatTests), but the value side is never envelope-wrapped at + // any protocol version. So the emitted structured content stays a plain object + // across versions. + JsonElement outputSchema = JsonDocument.Parse( + """{"type":["object","null"],"properties":{"name":{"type":"string"}}}""").RootElement; + McpServerTool tool = McpServerTool.Create(() => new Person("John", 27), new() + { + Name = "tool", + UseStructuredContent = true, + OutputSchema = outputSchema, + SerializerOptions = CreateSerializerOptionsWithPerson(), + }); + var request = CreateRequestContextWithProtocolVersion(protocolVersion); + + var result = await tool.InvokeAsync(request, TestContext.Current.CancellationToken); + + Assert.NotNull(result.StructuredContent); + Assert.Equal(JsonValueKind.Object, result.StructuredContent.Value.ValueKind); + Assert.False(result.StructuredContent.Value.TryGetProperty("result", out _)); + Assert.Equal("John", result.StructuredContent.Value.GetProperty("name").GetString()); + } + + private static RequestContext CreateRequestContextWithProtocolVersion(string? protocolVersion) + { + var mockServer = new Mock(); + mockServer.SetupGet(s => s.NegotiatedProtocolVersion).Returns(protocolVersion); + return new RequestContext(mockServer.Object, CreateTestJsonRpcRequest(), new CallToolRequestParams { Name = "tool" }); } [Fact] @@ -1004,15 +1176,15 @@ public void ReturnDescription_StructuredOutputDisabled_IncludedInToolDescription [Fact] public void ReturnDescription_StructuredOutputEnabled_NotIncludedInToolDescription() { - // When UseStructuredContent is true, return description should be in the output schema, not in tool description + // When UseStructuredContent is true, return description should be in the output schema, not in tool description. + // Per SEP-2106 the schema is no longer wrapped in a {"result": } envelope, so the description + // sits directly on the (non-object) output schema. McpServerTool tool = McpServerTool.Create(ToolWithReturnDescription, new() { UseStructuredContent = true }); Assert.Equal("Tool that returns data.", tool.ProtocolTool.Description); Assert.NotNull(tool.ProtocolTool.OutputSchema); - // Verify the output schema contains the description - Assert.True(tool.ProtocolTool.OutputSchema.Value.TryGetProperty("properties", out var properties)); - Assert.True(properties.TryGetProperty("result", out var result)); - Assert.True(result.TryGetProperty("description", out var description)); + Assert.Equal("string", tool.ProtocolTool.OutputSchema.Value.GetProperty("type").GetString()); + Assert.True(tool.ProtocolTool.OutputSchema.Value.TryGetProperty("description", out var description)); Assert.Equal("The computed result", description.GetString()); } @@ -1079,102 +1251,172 @@ public async Task EnablePollingAsync_ThrowsInvalidOperationException_WhenTranspo Assert.Contains("Streamable HTTP", exception.Message); } - [Fact] - public void AsyncTool_AutomaticallyMarkedWithTaskSupport() - { - // Async tools should automatically get TaskSupport = Optional - McpServerTool tool = McpServerTool.Create(AsyncToolReturningTask); + [Description("Tool that returns data.")] + [return: Description("The computed result")] + private static string ToolWithReturnDescription() => "result"; - Assert.NotNull(tool.ProtocolTool.Execution); - Assert.Equal(ToolTaskSupport.Optional, tool.ProtocolTool.Execution.TaskSupport); - } + [return: Description("The computed result")] + private static string ToolWithOnlyReturnDescription() => "result"; - [Fact] - public void AsyncTool_ValueTask_AutomaticallyMarkedWithTaskSupport() - { - // Async tools returning ValueTask should also get TaskSupport = Optional - McpServerTool tool = McpServerTool.Create(AsyncToolReturningValueTask); + [Description("Tool without return description.")] + private static string ToolWithoutReturnDescription() => "result"; - Assert.NotNull(tool.ProtocolTool.Execution); - Assert.Equal(ToolTaskSupport.Optional, tool.ProtocolTool.Execution.TaskSupport); - } + [JsonSourceGenerationOptions(PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase)] + [JsonSerializable(typeof(JsonNode))] + [JsonSerializable(typeof(DisposableToolType))] + [JsonSerializable(typeof(AsyncDisposableToolType))] + [JsonSerializable(typeof(AsyncDisposableAndDisposableToolType))] + [JsonSerializable(typeof(JsonSchema))] + [JsonSerializable(typeof(List))] + [JsonSerializable(typeof(List))] + [JsonSerializable(typeof(int?))] + [JsonSerializable(typeof(DateTimeOffset?))] + [JsonSerializable(typeof(Person))] + partial class JsonContext2 : JsonSerializerContext; + + // ===== x-mcp-header tests ===== [Fact] - public void AsyncTool_TaskOfT_AutomaticallyMarkedWithTaskSupport() + public void Create_WithMcpHeaderAttribute_AddsXMcpHeaderExtension() { - // Async tools returning Task should get TaskSupport = Optional - McpServerTool tool = McpServerTool.Create(AsyncToolReturningTaskOfT); - - Assert.NotNull(tool.ProtocolTool.Execution); - Assert.Equal(ToolTaskSupport.Optional, tool.ProtocolTool.Execution.TaskSupport); + var tool = McpServerTool.Create(typeof(McpHeaderToolType).GetMethod(nameof(McpHeaderToolType.ToolWithSingleHeader))!); + var schema = tool.ProtocolTool.InputSchema; + var props = schema.GetProperty("properties"); + var regionProp = props.GetProperty("region"); + Assert.True(regionProp.TryGetProperty("x-mcp-header", out var headerValue)); + Assert.Equal("Region", headerValue.GetString()); } [Fact] - public void AsyncTool_ValueTaskOfT_AutomaticallyMarkedWithTaskSupport() + public void Create_WithMultipleMcpHeaderAttributes_AddsAllExtensions() { - // Async tools returning ValueTask should get TaskSupport = Optional - McpServerTool tool = McpServerTool.Create(AsyncToolReturningValueTaskOfT); + var tool = McpServerTool.Create(typeof(McpHeaderToolType).GetMethod(nameof(McpHeaderToolType.ToolWithMultipleHeaders))!); + var schema = tool.ProtocolTool.InputSchema; + var props = schema.GetProperty("properties"); + + var regionProp = props.GetProperty("region"); + Assert.True(regionProp.TryGetProperty("x-mcp-header", out var regionHeader)); + Assert.Equal("Region", regionHeader.GetString()); - Assert.NotNull(tool.ProtocolTool.Execution); - Assert.Equal(ToolTaskSupport.Optional, tool.ProtocolTool.Execution.TaskSupport); + var tenantProp = props.GetProperty("tenantId"); + Assert.True(tenantProp.TryGetProperty("x-mcp-header", out var tenantHeader)); + Assert.Equal("TenantId", tenantHeader.GetString()); } [Fact] - public void SyncTool_NotMarkedWithTaskSupport() + public void Create_WithDuplicateHeaderNames_ThrowsInvalidOperationException() { - // Synchronous tools should not have TaskSupport set - McpServerTool tool = McpServerTool.Create(SyncTool); - - Assert.Null(tool.ProtocolTool.Execution); + Assert.Throws(() => + McpServerTool.Create(typeof(McpHeaderToolType).GetMethod(nameof(McpHeaderToolType.ToolWithDuplicateHeaders))!)); } - private static async Task AsyncToolReturningTask() + [Fact] + public void Create_WithMcpHeaderOnNonPrimitiveType_ThrowsInvalidOperationException() { - await Task.Yield(); + Assert.Throws(() => + McpServerTool.Create(typeof(McpHeaderToolType).GetMethod(nameof(McpHeaderToolType.ToolWithNonPrimitiveHeader))!)); } - private static async ValueTask AsyncToolReturningValueTask() + [Fact] + public void Create_WithMcpHeaderOnUInt64Type_ThrowsInvalidOperationException() { - await Task.Yield(); + // ulong is excluded per SEP-2243 because its domain extends beyond the JavaScript safe + // integer range (and beyond long), so it cannot be represented as a signed integer header. + Assert.Throws(() => + McpServerTool.Create(typeof(McpHeaderToolType).GetMethod(nameof(McpHeaderToolType.ToolWithUInt64Header))!)); } - private static async Task AsyncToolReturningTaskOfT() + [Fact] + public void Create_WithMcpHeaderOnNumericType_AddsExtension() { - await Task.Yield(); - return "result"; + var tool = McpServerTool.Create(typeof(McpHeaderToolType).GetMethod(nameof(McpHeaderToolType.ToolWithNumericHeader))!); + var schema = tool.ProtocolTool.InputSchema; + var props = schema.GetProperty("properties"); + var countProp = props.GetProperty("count"); + Assert.True(countProp.TryGetProperty("x-mcp-header", out var headerValue)); + Assert.Equal("Count", headerValue.GetString()); } - private static async ValueTask AsyncToolReturningValueTaskOfT() + [Fact] + public void Create_WithMcpHeaderOnBooleanType_AddsExtension() { - await Task.Yield(); - return "result"; + var tool = McpServerTool.Create(typeof(McpHeaderToolType).GetMethod(nameof(McpHeaderToolType.ToolWithBooleanHeader))!); + var schema = tool.ProtocolTool.InputSchema; + var props = schema.GetProperty("properties"); + var flagProp = props.GetProperty("flag"); + Assert.True(flagProp.TryGetProperty("x-mcp-header", out var headerValue)); + Assert.Equal("Flag", headerValue.GetString()); } - private static string SyncTool() + [Fact] + public void Create_WithMcpHeaderOnNullableType_AddsExtension() { - return "sync result"; + var tool = McpServerTool.Create(typeof(McpHeaderToolType).GetMethod(nameof(McpHeaderToolType.ToolWithNullableHeader))!); + var schema = tool.ProtocolTool.InputSchema; + var props = schema.GetProperty("properties"); + var countProp = props.GetProperty("count"); + Assert.True(countProp.TryGetProperty("x-mcp-header", out var headerValue)); + Assert.Equal("Count", headerValue.GetString()); } - [Description("Tool that returns data.")] - [return: Description("The computed result")] - private static string ToolWithReturnDescription() => "result"; - - [return: Description("The computed result")] - private static string ToolWithOnlyReturnDescription() => "result"; - - [Description("Tool without return description.")] - private static string ToolWithoutReturnDescription() => "result"; - - [JsonSourceGenerationOptions(PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase)] - [JsonSerializable(typeof(JsonNode))] - [JsonSerializable(typeof(DisposableToolType))] - [JsonSerializable(typeof(AsyncDisposableToolType))] - [JsonSerializable(typeof(AsyncDisposableAndDisposableToolType))] - [JsonSerializable(typeof(JsonSchema))] - [JsonSerializable(typeof(List))] - [JsonSerializable(typeof(List))] - [JsonSerializable(typeof(int?))] - [JsonSerializable(typeof(DateTimeOffset?))] - [JsonSerializable(typeof(Person))] - partial class JsonContext2 : JsonSerializerContext; + [Fact] + public void Create_WithoutMcpHeaderAttribute_NoXMcpHeaderExtension() + { + var tool = McpServerTool.Create(typeof(McpHeaderToolType).GetMethod(nameof(McpHeaderToolType.ToolWithoutHeaders))!); + var schema = tool.ProtocolTool.InputSchema; + var props = schema.GetProperty("properties"); + var regionProp = props.GetProperty("region"); + Assert.False(regionProp.TryGetProperty("x-mcp-header", out _)); + } + + private static class McpHeaderToolType + { + [McpServerTool] + public static string ToolWithSingleHeader( + [McpHeader("Region")] string region, + string query) + => "result"; + + [McpServerTool] + public static string ToolWithMultipleHeaders( + [McpHeader("Region")] string region, + [McpHeader("TenantId")] string tenantId, + string query) + => "result"; + + [McpServerTool] + public static string ToolWithDuplicateHeaders( + [McpHeader("Region")] string region1, + [McpHeader("REGION")] string region2) + => "result"; + + [McpServerTool] + public static string ToolWithNonPrimitiveHeader( + [McpHeader("Data")] object data) + => "result"; + + [McpServerTool] + public static string ToolWithNumericHeader( + [McpHeader("Count")] int count) + => "result"; + + [McpServerTool] + public static string ToolWithBooleanHeader( + [McpHeader("Flag")] bool flag) + => "result"; + + [McpServerTool] + public static string ToolWithNullableHeader( + [McpHeader("Count")] int? count) + => "result"; + + [McpServerTool] + public static string ToolWithoutHeaders(string region, string query) + => "result"; + + [McpServerTool] + public static string ToolWithUInt64Header( + [McpHeader("Count")] ulong count) + => "result"; + } } diff --git a/tests/ModelContextProtocol.Tests/Server/McpTaskStoreTests.cs b/tests/ModelContextProtocol.Tests/Server/McpTaskStoreTests.cs new file mode 100644 index 000000000..ebf7ca4ad --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/McpTaskStoreTests.cs @@ -0,0 +1,821 @@ +using ModelContextProtocol.Extensions.Tasks; +using Microsoft.Extensions.AI; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using Microsoft.Extensions.DependencyInjection; +using System.Runtime.InteropServices; +using System.Text.Json; +using System.Threading.Channels; + +#pragma warning disable MCPEXP001 + +namespace ModelContextProtocol.Tests.Server; + +/// +/// Tests for the -based auto-wiring of tools/call into tasks. +/// Verifies that enables task support +/// for -based tools. +/// +public class McpTaskStoreTests : ClientServerTestBase +{ + public McpTaskStoreTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) + { +#if !NET + Assert.SkipWhen(RuntimeInformation.IsOSPlatform(OSPlatform.Windows), "https://github.com/modelcontextprotocol/csharp-sdk/issues/587"); +#endif + } + + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + mcpServerBuilder + .WithTools() + .WithTasks(new InMemoryMcpTaskStore + { + DefaultPollIntervalMs = 50, + }, options => options.ExecutionModeSelector = request => + request.Params?.Name switch + { + "sync-tool" => McpTaskExecutionMode.Synchronous, + "required-tool" => McpTaskExecutionMode.Required, + _ => McpTaskExecutionMode.Optional, + }); + } + + [Fact] + public async Task CallToolAsTaskAsync_WithTaskCapability_ReturnsCreateTaskResult() + { + await using var client = await CreateMcpClientForServer(); + + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "slow-tool" }, + TestContext.Current.CancellationToken); + + // Because the client signals task support and a TaskStore is configured, + // the server should wrap the tool execution in a task. + Assert.True(augmented.IsTask); + Assert.NotNull(augmented.TaskCreated); + Assert.Equal(McpTaskStatus.Working, augmented.TaskCreated.Status); + } + + [Fact] + public async Task CallToolAsync_SynchronousExecutionMode_ReturnsResultDirectly() + { + await using McpClient client = await CreateMcpClientForServer(); + + CallToolResult result = await client.CallToolAsync( + "sync-tool", + cancellationToken: TestContext.Current.CancellationToken); + + Assert.Equal("sync", Assert.IsType(result.Content[0]).Text); + } + + [Fact] + public async Task CallToolAsync_RequiredExecutionModeWithoutCapability_Throws() + { + await using McpClient client = await CreateMcpClientForServer(); + + MissingRequiredClientCapabilityException exception = await Assert.ThrowsAsync(async () => + await client.CallToolAsync( + "required-tool", + cancellationToken: TestContext.Current.CancellationToken)); + + Assert.Equal(McpErrorCode.MissingRequiredClientCapability, exception.ErrorCode); + } + + [Fact] + public async Task CallToolAsync_RequiredExecutionModeWithLegacyProtocol_Throws() + { + await using McpClient client = await CreateMcpClientForServer(new McpClientOptions + { + ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion, + }); + + MissingRequiredClientCapabilityException exception = await Assert.ThrowsAsync(async () => + await client.CallToolAsync( + "required-tool", + cancellationToken: TestContext.Current.CancellationToken)); + + Assert.Equal(McpErrorCode.MissingRequiredClientCapability, exception.ErrorCode); + } + + [Fact] + public async Task CallToolAsTaskAsync_RequiredExecutionMode_ReturnsTask() + { + await using McpClient client = await CreateMcpClientForServer(); + + ResultOrCreatedTask result = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "required-tool" }, + TestContext.Current.CancellationToken); + + Assert.True(result.IsTask); + + CallToolResult completedResult = await client.CallToolWithPollingAsync( + new CallToolRequestParams { Name = "required-tool" }, + cancellationToken: TestContext.Current.CancellationToken); + + Assert.Equal("required", Assert.IsType(completedResult.Content[0]).Text); + } + + [Fact] + public void WithTasks_NullExecutionModeSelector_Throws() + { + ServiceCollection services = new(); + + Assert.Throws(() => + services + .AddMcpServer() + .WithStreamServerTransport(Stream.Null, Stream.Null) + .WithTasks( + new InMemoryMcpTaskStore(), + options => options.ExecutionModeSelector = null!)); + } + + [Fact] + public async Task CallToolAsync_WithTaskStore_PollsToCompletion() + { + await using var client = await CreateMcpClientForServer(); + + // CallToolAsync should poll until the background execution completes. + var result = await client.CallToolWithPollingAsync( + new CallToolRequestParams { Name = "slow-tool" }, + cancellationToken: TestContext.Current.CancellationToken); + + Assert.NotNull(result); + Assert.Single(result.Content); + Assert.Equal("slow result", Assert.IsType(result.Content[0]).Text); + } + + [Fact] + public async Task CallToolAsync_WithTaskStore_FastTool_StillCreatesTask() + { + await using var client = await CreateMcpClientForServer(); + + // Even a fast tool should go through the task store when the client signals capability. + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "fast-tool" }, + TestContext.Current.CancellationToken); + + Assert.True(augmented.IsTask); + } + + [Fact] + public async Task GetTaskAsync_ViaStore_ReturnsCompletedResult() + { + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; + + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "fast-tool" }, cancellationToken: ct); + + var taskId = augmented.TaskCreated!.TaskId; + + // The fast-tool returns immediately in the background, so poll briefly + GetTaskResult? taskResult = null; + for (int i = 0; i < 20; i++) + { + await Task.Delay(50, ct); + taskResult = await client.GetTaskAsync(taskId, ct); + if (taskResult is CompletedTaskResult) + { + break; + } + } + + Assert.IsType(taskResult); + } + + [Fact] + public async Task CancelTaskAsync_ViaStore_TransitionsToCancelled() + { + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; + + // Create a slow task that won't complete on its own + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "slow-tool" }, ct); + + var taskId = augmented.TaskCreated!.TaskId; + + // Cancel it + await client.CancelTaskAsync(taskId, ct); + + // Verify state + var taskResult = await client.GetTaskAsync(taskId, ct); + Assert.IsType(taskResult); + } + + [Fact] + public async Task GetTaskAsync_UnknownId_ThrowsWithInvalidParams() + { + await using var client = await CreateMcpClientForServer(); + + var ex = await Assert.ThrowsAsync(async () => + await client.GetTaskAsync("nonexistent-id", TestContext.Current.CancellationToken)); + + Assert.Contains("Unknown task", ex.Message); + } + + [Fact] + public async Task ToolExecution_Failure_StoresAsCompletedWithError() + { + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; + + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "failing-tool" }, ct); + + var taskId = augmented.TaskCreated!.TaskId; + + // Poll until completed (tool exceptions are wrapped as isError:true results) + GetTaskResult? taskResult = null; + for (int i = 0; i < 20; i++) + { + await Task.Delay(50, ct); + taskResult = await client.GetTaskAsync(taskId, ct); + if (taskResult is CompletedTaskResult) + { + break; + } + } + + var completed = Assert.IsType(taskResult); + // The tool result has isError: true + Assert.True(completed.Result.GetProperty("isError").GetBoolean()); + } + + [Fact] + public async Task McpProtocolException_FromTool_StoresAsFailedWithJsonRpcErrorShape() + { + // SEP-2663 §186: failed.error MUST be a JSON-RPC error object {code, message, data?}. + // When a tool throws McpProtocolException, the task-store wrapper must serialize the error + // payload with the exception's ErrorCode and Message preserved on the wire. + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; + + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "throws-mcp-protocol" }, ct); + + var taskId = augmented.TaskCreated!.TaskId; + + GetTaskResult? taskResult = null; + for (int i = 0; i < 20; i++) + { + await Task.Delay(50, ct); + taskResult = await client.GetTaskAsync(taskId, ct); + if (taskResult is FailedTaskResult) + { + break; + } + } + + var failed = Assert.IsType(taskResult); + + // The error MUST be a JSON-RPC error object with at least 'code' and 'message'. + Assert.Equal(JsonValueKind.Object, failed.Error.ValueKind); + Assert.Equal((int)McpErrorCode.InvalidParams, failed.Error.GetProperty("code").GetInt32()); + Assert.Equal("custom-protocol-message", failed.Error.GetProperty("message").GetString()); + } + + [Fact] + public async Task InputRequiredException_FromTool_FailsTaskWithActionableMessage() + { + // [McpServerTool] methods that throw InputRequiredException can't compose with the task-store + // wrapper today: the taskId was already returned synchronously and there's no way to surface + // InputRequiredResult retroactively. The wrapper must fail the task with a clear, actionable + // message instead of leaking the raw exception through the generic catch. + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; + + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "mrtr-tool" }, ct); + + var taskId = augmented.TaskCreated!.TaskId; + + GetTaskResult? taskResult = null; + for (int i = 0; i < 20; i++) + { + await Task.Delay(50, ct); + taskResult = await client.GetTaskAsync(taskId, ct); + if (taskResult is FailedTaskResult) + { + break; + } + } + + var failed = Assert.IsType(taskResult); + Assert.Equal(JsonValueKind.Object, failed.Error.ValueKind); + Assert.Equal((int)McpErrorCode.InvalidRequest, failed.Error.GetProperty("code").GetInt32()); + + var message = failed.Error.GetProperty("message").GetString(); + Assert.NotNull(message); + Assert.Contains("MRTR", message); + Assert.Contains("tasks", message); + } + + [Fact] + public async Task ElicitTool_ViaTask_RedirectsThroughStore() + { + await using var client = await CreateMcpClientForServer(new McpClientOptions + { + Handlers = new McpClientHandlers + { + ElicitationHandler = (request, ct) => + { + // Client responds to the elicitation + return new ValueTask(new ElicitResult { Action = "accept" }); + } + } + }); + var ct = TestContext.Current.CancellationToken; + + // CallToolAsync will poll and resolve input requests automatically. + var result = await client.CallToolWithPollingAsync( + new CallToolRequestParams { Name = "elicit-tool" }, cancellationToken: ct); + + Assert.NotNull(result); + Assert.Equal("accepted", Assert.IsType(result.Content[0]).Text); + } + + [Fact] + public async Task SampleTool_ViaTask_RedirectsThroughStore() + { + await using var client = await CreateMcpClientForServer(new McpClientOptions + { + Handlers = new McpClientHandlers + { + SamplingHandler = (request, progress, ct) => + { + return new ValueTask(new CreateMessageResult + { + Content = [new TextContentBlock { Text = "sampled response" }], + Model = "test-model", + }); + } + } + }); + var ct = TestContext.Current.CancellationToken; + + var result = await client.CallToolWithPollingAsync( + new CallToolRequestParams { Name = "sample-tool" }, cancellationToken: ct); + + Assert.NotNull(result); + Assert.Equal("sampled response", Assert.IsType(result.Content[0]).Text); + } + + [Fact] + public async Task RootsTool_ViaTask_RedirectsThroughStore() + { + // Verifies that server-initiated roots/list calls issued from inside a [McpServerTool] + // running under the task wrapper are redirected through the task store as input requests + // (rather than being sent as direct JSON-RPC requests to the client). + await using var client = await CreateMcpClientForServer(new McpClientOptions + { + Capabilities = new ClientCapabilities + { + Roots = new RootsCapability(), + }, + Handlers = new McpClientHandlers + { + RootsHandler = (request, ct) => + new ValueTask(new ListRootsResult + { + Roots = [new Root { Uri = "file:///workspace" }, new Root { Uri = "file:///other" }], + }), + }, + }); + var ct = TestContext.Current.CancellationToken; + + var result = await client.CallToolWithPollingAsync( + new CallToolRequestParams { Name = "roots-tool" }, cancellationToken: ct); + + Assert.NotNull(result); + Assert.Equal("file:///workspace,file:///other", Assert.IsType(result.Content[0]).Text); + } + + [Fact] + public async Task SendTaskStatusNotificationAsync_FromTool_DeliversTypedNotificationE2E() + { + // E2E coverage for SendTaskStatusNotificationAsync: the tool emits a Working then a + // Completed notification with a fixed test taskId, and the client receives them via + // its notifications/tasks subscription, deserialized to the right concrete subtype. + var notifications = Channel.CreateUnbounded(); + + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; + + await using var registration = client.RegisterNotificationHandler( + TasksProtocol.NotificationTaskStatus, + (notification, _) => + { + var typed = JsonSerializer.Deserialize(notification.Params, McpTasksJsonContext.Default.Options); + if (typed is not null) + { + notifications.Writer.TryWrite(typed); + } + + return default; + }); + + var result = await client.CallToolWithPollingAsync( + new CallToolRequestParams { Name = "notifying-tool" }, cancellationToken: ct); + + Assert.Equal("notified", Assert.IsType(result.Content[0]).Text); + + // Read both notifications. The server emits them in strict order (each + // SendTaskStatusNotificationAsync awaits the transport write before the next), but client-side + // dispatch (McpSessionHandler.ProcessMessageAsync) is fire-and-forget per message, so user + // handlers may observe them out of order. Reconstruct send order via the server-set + // LastUpdatedAt timestamp. + var first = await notifications.Reader.ReadAsync(ct); + var second = await notifications.Reader.ReadAsync(ct); + var ordered = new[] { first, second }.OrderBy(n => n.LastUpdatedAt).ToArray(); + + var workingTyped = Assert.IsType(ordered[0]); + Assert.Equal("notify-test-task-id", workingTyped.TaskId); + Assert.Equal(McpTaskStatus.Working, workingTyped.Status); + + var completedTyped = Assert.IsType(ordered[1]); + Assert.Equal("notify-test-task-id", completedTyped.TaskId); + Assert.Equal(McpTaskStatus.Completed, completedTyped.Status); + Assert.Equal("notify-result", completedTyped.Result.GetString()); + } + + [Fact] + public async Task SendTaskStatusNotificationAsync_Failed_DeliversTypedNotificationE2E() + { + // Companion to the Working/Completed test above, covering the Failed branch which + // carries the required JsonElement Error payload. + var notifications = Channel.CreateUnbounded(); + + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; + + await using var registration = client.RegisterNotificationHandler( + TasksProtocol.NotificationTaskStatus, + (notification, _) => + { + var typed = JsonSerializer.Deserialize(notification.Params, McpTasksJsonContext.Default.Options); + if (typed is FailedTaskNotificationParams) + { + notifications.Writer.TryWrite(typed); + } + + return default; + }); + + // The tool emits a Failed notification then returns a normal result, so we isolate the + // notification round-trip from the task-store's own failure handling. + var result = await client.CallToolWithPollingAsync( + new CallToolRequestParams { Name = "failing-notify-tool" }, cancellationToken: ct); + + Assert.Equal("emitted-failed", Assert.IsType(result.Content[0]).Text); + + var failed = await notifications.Reader.ReadAsync(ct); + var typed = Assert.IsType(failed); + Assert.Equal("failing-notify-task-id", typed.TaskId); + Assert.Equal(McpTaskStatus.Failed, typed.Status); + Assert.Equal(-32000, typed.Error.GetProperty("code").GetInt32()); + Assert.Equal("boom", typed.Error.GetProperty("message").GetString()); + } + + [Fact] + public async Task ElicitTool_ViaTask_ClientDedups_InputRequests() + { + // This test verifies that the client doesn't re-resolve an input request + // that it has already responded to in a previous poll cycle. + int elicitCallCount = 0; + + await using var client = await CreateMcpClientForServer(new McpClientOptions + { + Handlers = new McpClientHandlers + { + ElicitationHandler = (request, ct) => + { + Interlocked.Increment(ref elicitCallCount); + return new ValueTask(new ElicitResult { Action = "accept" }); + } + } + }); + var ct = TestContext.Current.CancellationToken; + + var result = await client.CallToolWithPollingAsync( + new CallToolRequestParams { Name = "elicit-tool" }, cancellationToken: ct); + + // The handler should be called exactly once despite potential multiple polls + Assert.Equal(1, elicitCallCount); + Assert.Equal("accepted", Assert.IsType(result.Content[0]).Text); + } + + [Fact] + public async Task CallToolAsTaskAsync_ElicitTool_ReturnsTask_ThenPollShowsInputRequired() + { + await using var client = await CreateMcpClientForServer(new McpClientOptions + { + Handlers = new McpClientHandlers + { + ElicitationHandler = (request, ct) => + new ValueTask(new ElicitResult { Action = "accept" }) + } + }); + var ct = TestContext.Current.CancellationToken; + + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "elicit-tool" }, ct); + + Assert.True(augmented.IsTask); + var taskId = augmented.TaskCreated!.TaskId; + + // Poll — eventually the task should be input_required (elicit-tool calls ElicitAsync) + GetTaskResult? taskResult = null; + for (int i = 0; i < 40; i++) + { + await Task.Delay(50, ct); + taskResult = await client.GetTaskAsync(taskId, ct); + if (taskResult is InputRequiredTaskResult) + { + break; + } + } + + Assert.IsType(taskResult); + } + + [Fact] + public async Task CancelTaskAsync_AlreadyCompleted_AcknowledgesIdempotently_AndDoesNotResurrect() + { + // Exercises the SDK's default tasks/cancel handler against the real InMemoryMcpTaskStore. + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; + + // Run a fast tool to completion via the task store. + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "fast-tool" }, ct); + var taskId = augmented.TaskCreated!.TaskId; + + GetTaskResult? taskResult = null; + for (int i = 0; i < 40 && taskResult is not CompletedTaskResult; i++) + { + await Task.Delay(50, ct); + taskResult = await client.GetTaskAsync(taskId, ct); + } + Assert.IsType(taskResult); + + // SEP-2663: tasks/cancel must be acknowledged idempotently even after the task has completed. + var cancelResult = await client.CancelTaskAsync(taskId, ct); + Assert.NotNull(cancelResult); + + // The task must remain Completed and the result must not be lost. + var verifyResult = await client.GetTaskAsync(taskId, ct); + var stillCompleted = Assert.IsType(verifyResult); + Assert.NotEqual(default(JsonElement), stillCompleted.Result); + } + + [Fact] + public async Task CallToolAsync_ElicitHandlerThrows_PropagatesAndDoesNotLeaveClientStuck() + { + // Verifies bug fix: when the client-side input handler throws while resolving an + // InputRequired task, the exception propagates promptly (instead of the poll loop + // hanging) and the client issues a best-effort tasks/cancel to release the server. + await using var client = await CreateMcpClientForServer(new McpClientOptions + { + Handlers = new McpClientHandlers + { + ElicitationHandler = (request, ct) => + throw new InvalidOperationException("handler-failed"), + } + }); + var ct = TestContext.Current.CancellationToken; + + var sw = System.Diagnostics.Stopwatch.StartNew(); + var ex = await Assert.ThrowsAsync(async () => + await client.CallToolWithPollingAsync(new CallToolRequestParams { Name = "elicit-tool" }, cancellationToken: ct)); + sw.Stop(); + + Assert.Equal("handler-failed", ex.Message); + + // Must fail fast: without the fix this would keep polling until the test cancellation token fires. + // Allow generous slack for CI but well under the test timeout. + Assert.True(sw.Elapsed < TimeSpan.FromSeconds(10), + $"CallToolAsync should propagate input handler exceptions promptly but took {sw.Elapsed}."); + } + + [Fact] + public async Task CallTool_WithoutTaskExtensionMeta_ReturnsCallToolResultImmediately() + { + // SEP-2663: "A server MUST NOT return a CreateTaskResult to a client that did not include the + // extension capability." We bypass CallToolAsTaskAsync (which injects the marker) and send a raw + // tools/call request without the io.modelcontextprotocol/tasks key in _meta. + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; + + var result = await client.SendRequestAsync( + RequestMethods.ToolsCall, + new CallToolRequestParams { Name = "fast-tool" }, + serializerOptions: McpJsonUtilities.DefaultOptions, + cancellationToken: ct); + + // Server should return a regular CallToolResult, never escalate to a task. + Assert.NotNull(result); + Assert.NotNull(result.Content); + Assert.Equal("fast result", Assert.IsType(result.Content[0]).Text); + + // resultType is reserved and must not be the "task" discriminator for plain results. + Assert.NotEqual("task", result.ResultType); + } + + [Fact] + public async Task ToolReturnsCallToolResultWithIsError_AsTask_StoresAsCompleted_NotFailed() + { + // SEP-2663: "An MCP server MUST NOT use [Failed] for errors that would have been signaled + // by setting `CallToolResult.isError` to true ... Such errors are domain-level errors, and + // their result MUST be returned by the server in the same way that any standard call-tool + // result is returned." So a tool that returns isError:true MUST end up as a Completed task. + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; + + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "iserror-tool" }, ct); + + var taskId = augmented.TaskCreated!.TaskId; + + GetTaskResult? taskResult = null; + for (int i = 0; i < 40 && taskResult is not CompletedTaskResult; i++) + { + await Task.Delay(50, ct); + taskResult = await client.GetTaskAsync(taskId, ct); + } + + var completed = Assert.IsType(taskResult); + Assert.Equal(McpTaskStatus.Completed, completed.Status); + Assert.True(completed.Result.GetProperty("isError").GetBoolean()); + } + + [Fact] + public async Task MultiElicit_ViaTask_HandlerCalledExactlyOncePerUniqueKey_AcrossPolls() + { + // SEP-2663: "Each entry [in inputRequests] MUST be treated as if it were an equivalent + // standalone server-to-client request" and "clients SHOULD use [keys] to deduplicate". + // A tool that fires two concurrent server->client requests produces two unique keys; the + // client must dispatch the handler exactly twice in total, even across multiple polls. + int elicitCount = 0; + var observedMessages = new System.Collections.Concurrent.ConcurrentBag(); + + await using var client = await CreateMcpClientForServer(new McpClientOptions + { + Handlers = new McpClientHandlers + { + ElicitationHandler = (request, ct) => + { + Interlocked.Increment(ref elicitCount); + observedMessages.Add(request?.Message ?? string.Empty); + return new ValueTask(new ElicitResult { Action = "accept" }); + } + } + }); + var ct = TestContext.Current.CancellationToken; + + var result = await client.CallToolWithPollingAsync( + new CallToolRequestParams { Name = "multi-elicit-tool" }, cancellationToken: ct); + + // Exactly two handler invocations — one per unique input request key. + Assert.Equal(2, elicitCount); + Assert.Contains("first", observedMessages); + Assert.Contains("second", observedMessages); + Assert.Equal("accept|accept", Assert.IsType(result.Content[0]).Text); + } + + [McpServerToolType] + private sealed class TaskStoreTestTools + { + [McpServerTool(Name = "sync-tool")] + public static string SyncTool() => "sync"; + + [McpServerTool(Name = "required-tool")] + public static string RequiredTool() => "required"; + + [McpServerTool(Name = "slow-tool"), System.ComponentModel.Description("A tool that takes time")] + public static async Task SlowTool(CancellationToken cancellationToken) + { + await Task.Delay(200, cancellationToken); + return "slow result"; + } + + [McpServerTool(Name = "fast-tool"), System.ComponentModel.Description("A fast tool")] + public static string FastTool() => "fast result"; + + [McpServerTool(Name = "failing-tool"), System.ComponentModel.Description("A tool that fails")] + public static string FailingTool() => throw new InvalidOperationException("intentional failure"); + + [McpServerTool(Name = "throws-mcp-protocol"), System.ComponentModel.Description("A tool that throws McpProtocolException")] + public static string ThrowsMcpProtocol() => + throw new McpProtocolException("custom-protocol-message", McpErrorCode.InvalidParams); + + [McpServerTool(Name = "mrtr-tool"), System.ComponentModel.Description("A tool that throws InputRequiredException (MRTR)")] + public static string MrtrTool() => + throw new InputRequiredException(requestState: "test-state"); + + [McpServerTool(Name = "elicit-tool"), System.ComponentModel.Description("A tool that elicits")] + public static async Task ElicitTool(McpServer server, CancellationToken cancellationToken) + { + var result = await server.ElicitAsync(new ElicitRequestParams + { + Message = "What is your name?", + RequestedSchema = new(), + }, cancellationToken); + + return result.Action == "accept" ? "accepted" : "declined"; + } + + [McpServerTool(Name = "sample-tool"), System.ComponentModel.Description("A tool that samples")] + public static async Task SampleTool(McpServer server, CancellationToken cancellationToken) + { + var result = await server.SampleAsync(new CreateMessageRequestParams + { + Messages = [new SamplingMessage { Role = Role.User, Content = [new TextContentBlock { Text = "hello" }] }], + MaxTokens = 100, + }, cancellationToken); + + return result.Content.OfType().FirstOrDefault()?.Text ?? "no response"; + } + + [McpServerTool(Name = "roots-tool"), System.ComponentModel.Description("A tool that lists roots")] + public static async Task RootsTool(McpServer server, CancellationToken cancellationToken) + { + var result = await server.RequestRootsAsync(new ListRootsRequestParams(), cancellationToken); + return string.Join(",", result.Roots.Select(r => r.Uri)); + } + + [McpServerTool(Name = "notifying-tool"), System.ComponentModel.Description("A tool that emits SendTaskStatusNotificationAsync from inside the task wrapper")] + public static async Task NotifyingTool(McpServer server, CancellationToken cancellationToken) + { + var createdAt = DateTimeOffset.UtcNow; + + // Emit working then completed notifications using the public SendTaskStatusNotificationAsync API, + // so the test asserts the wire round-trip end-to-end (server → transport → client handler). + // Use distinct LastUpdatedAt values so the test can reconstruct send order on the receive side + // (client-side dispatch via McpSessionHandler.ProcessMessageAsync is fire-and-forget per message + // and may surface notifications to user handlers out of receipt order). + await server.SendTaskStatusNotificationAsync(new WorkingTaskNotificationParams + { + TaskId = "notify-test-task-id", + CreatedAt = createdAt, + LastUpdatedAt = createdAt, + }, cancellationToken); + + await server.SendTaskStatusNotificationAsync(new CompletedTaskNotificationParams + { + TaskId = "notify-test-task-id", + CreatedAt = createdAt, + LastUpdatedAt = createdAt.AddTicks(1), + Result = JsonElement.Parse("\"notify-result\""), + }, cancellationToken); + + return "notified"; + } + + [McpServerTool(Name = "failing-notify-tool"), System.ComponentModel.Description("A tool that emits a FailedTaskNotificationParams via SendTaskStatusNotificationAsync")] + public static async Task FailingNotifyTool(McpServer server, CancellationToken cancellationToken) + { + var now = DateTimeOffset.UtcNow; + var errorJson = JsonElement.Parse("""{"code":-32000,"message":"boom"}"""); + + await server.SendTaskStatusNotificationAsync(new FailedTaskNotificationParams + { + TaskId = "failing-notify-task-id", + CreatedAt = now, + LastUpdatedAt = now, + Error = errorJson, + }, cancellationToken); + + return "emitted-failed"; + } + + [McpServerTool(Name = "iserror-tool"), System.ComponentModel.Description("A tool that returns IsError=true without throwing")] + public static CallToolResult IsErrorTool() => new() + { + IsError = true, + Content = [new TextContentBlock { Text = "domain-error" }], + }; + + [McpServerTool(Name = "multi-elicit-tool"), System.ComponentModel.Description("A tool that issues two parallel elicitations")] + public static async Task MultiElicitTool(McpServer server, CancellationToken cancellationToken) + { + var first = server.ElicitAsync(new ElicitRequestParams + { + Message = "first", + RequestedSchema = new(), + }, cancellationToken); + + var second = server.ElicitAsync(new ElicitRequestParams + { + Message = "second", + RequestedSchema = new(), + }, cancellationToken); + + await Task.WhenAll(first.AsTask(), second.AsTask()); + + return $"{first.Result.Action}|{second.Result.Action}"; + } + } +} diff --git a/tests/ModelContextProtocol.Tests/Server/MrtrHandlerLifecycleTests.cs b/tests/ModelContextProtocol.Tests/Server/MrtrHandlerLifecycleTests.cs new file mode 100644 index 000000000..b80effede --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/MrtrHandlerLifecycleTests.cs @@ -0,0 +1,462 @@ +using Microsoft.Extensions.AI; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using ModelContextProtocol.Tests.Utils; +using System.Text.Json; + +namespace ModelContextProtocol.Tests.Server; + +/// +/// Tests for the server's MRTR handler lifecycle management - cancellation, disposal, and error +/// logging during multi round-trip request processing. +/// +public class MrtrHandlerLifecycleTests : ClientServerTestBase +{ + private readonly TaskCompletionSource _handlerTokenCancelled = new(TaskCreationOptions.RunContinuationsAsynchronously); + private readonly TaskCompletionSource _handlerStarted = new(TaskCreationOptions.RunContinuationsAsynchronously); + private readonly TaskCompletionSource _handlerResumed = new(TaskCreationOptions.RunContinuationsAsynchronously); + private readonly TaskCompletionSource _releaseHandler = new(TaskCreationOptions.RunContinuationsAsynchronously); + private readonly ServerMessageTracker _messageTracker = new(); + + public MrtrHandlerLifecycleTests(ITestOutputHelper testOutputHelper) + : base(testOutputHelper, startServer: false) + { + } + + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + services.AddLogging(builder => builder.SetMinimumLevel(LogLevel.Debug)); + services.Configure(options => + { + options.ProtocolVersion = "2026-07-28"; + _messageTracker.AddFilters(options.Filters.Message); + }); + + mcpServerBuilder.WithTools([ + McpServerTool.Create( + async (string message, McpServer server, CancellationToken ct) => + { + var result = await server.ElicitAsync(new ElicitRequestParams + { + Message = message, + RequestedSchema = new() + }, ct); + + return $"{result.Action}:{result.Content?.FirstOrDefault().Value}"; + }, + new McpServerToolCreateOptions + { + Name = "elicitation-tool", + Description = "A tool that requests elicitation from the client" + }), + McpServerTool.Create( + async (McpServer server, CancellationToken ct) => + { + var handlerTokenCancelled = _handlerTokenCancelled; + ct.Register(static state => ((TaskCompletionSource)state!).TrySetResult(true), handlerTokenCancelled); + _handlerStarted.TrySetResult(true); + + await server.ElicitAsync(new ElicitRequestParams + { + Message = "Cancellation test", + RequestedSchema = new() + }, ct); + + return "done"; + }, + new McpServerToolCreateOptions + { + Name = "cancellation-test-tool", + Description = "A tool that monitors its CancellationToken during MRTR" + }), + McpServerTool.Create( + async (string message, McpServer server, CancellationToken ct) => + { + // Elicit first, then block forever - the retry request stays in-flight + // until the client cancels, verifying that notifications/cancelled for + // the retry's request ID flows through to cancel this handler. + _handlerStarted.TrySetResult(true); + var result = await server.ElicitAsync(new ElicitRequestParams + { + Message = message, + RequestedSchema = new() + }, ct); + + // Signal that we resumed after ElicitAsync, then block. + _handlerResumed.TrySetResult(true); + await Task.Delay(Timeout.Infinite, ct); + return "unreachable"; + }, + new McpServerToolCreateOptions + { + Name = "elicit-then-block-tool", + Description = "A tool that elicits then blocks forever for cancellation testing" + }), + McpServerTool.Create( + async (McpServer server, CancellationToken ct) => + { + // Two sequential MRTR rounds. The client will inject a stale cancellation + // notification for the original request ID between round 1 and round 2. + var r1 = await server.ElicitAsync(new ElicitRequestParams + { + Message = "First elicitation", + RequestedSchema = new() + }, ct); + + // Signal that round 1 completed so the test can inject the stale notification. + _handlerResumed.TrySetResult(true); + + var r2 = await server.ElicitAsync(new ElicitRequestParams + { + Message = "Second elicitation", + RequestedSchema = new() + }, ct); + + return $"{r1.Action},{r2.Action}"; + }, + new McpServerToolCreateOptions + { + Name = "double-elicit-tool", + Description = "A tool that elicits twice for stale cancellation testing" + }), + McpServerTool.Create( + async (string message, McpServer server, CancellationToken ct) => + { + // Elicit, resume, then wait on _releaseHandler for the dispose test. + _handlerStarted.TrySetResult(true); + await server.ElicitAsync(new ElicitRequestParams + { + Message = message, + RequestedSchema = new() + }, ct); + + _handlerResumed.TrySetResult(true); + await _releaseHandler.Task; + return "handler-completed"; + }, + new McpServerToolCreateOptions + { + Name = "dispose-wait-tool", + Description = "A tool that elicits, resumes, then waits on a signal for disposal testing" + }), + McpServerTool.Create( + async (McpServer server, CancellationToken ct) => + { + await server.ElicitAsync(new ElicitRequestParams + { + Message = "elicit-then-throw", + RequestedSchema = new() + }, ct); + + throw new InvalidOperationException("Deliberate MRTR handler error for testing"); + }, + new McpServerToolCreateOptions + { + Name = "elicit-then-throw-tool", + Description = "A tool that elicits then throws an exception for error logging testing" + }), + McpServerTool.Create( + (McpServer server) => + { + // Low-level MRTR: throw InputRequiredException directly instead of using ElicitAsync. + // This should NOT be logged at Error level - it's normal MRTR control flow. + throw new InputRequiredException(new InputRequiredResult + { + InputRequests = new Dictionary + { + ["input_1"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "low-level elicit", + RequestedSchema = new() + }) + } + }); + }, + new McpServerToolCreateOptions + { + Name = "incomplete-result-tool", + Description = "A tool that throws InputRequiredException for low-level MRTR" + }) + ]); + } + + [Fact] + public async Task CallToolAsync_CancellationDuringMrtrRetry_ThrowsOperationCanceled() + { + // Verify that cancelling the CancellationToken during the MRTR retry loop + // (specifically during the elicitation handler callback) stops the loop. + StartServer(); + var cts = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken); + + var clientOptions = new McpClientOptions { ProtocolVersion = "2026-07-28" }; + clientOptions.Handlers.ElicitationHandler = (request, ct) => + { + // Cancel the token during the callback. The retry loop will throw + // OperationCanceledException on the next await after this handler returns. + cts.Cancel(); + return new ValueTask(new ElicitResult { Action = "accept" }); + }; + + await using var client = await CreateMcpClientForServer(clientOptions); + + await Assert.ThrowsAsync(async () => + await client.CallToolAsync("elicitation-tool", + new Dictionary { ["message"] = "test" }, + cancellationToken: cts.Token)); + + _messageTracker.AssertMrtrUsed(); + } + + [Fact] + public async Task ServerDisposal_CancelsHandlerCancellationToken_DuringMrtr() + { + // Verify that disposing the server cancels the handler's own CancellationToken + // (the `ct` parameter), not just the exchange ResponseTcs. Before the HandlerCts fix, + // the handler's CT was from a disposed CTS and could never be triggered. + StartServer(); + var elicitHandlerCalled = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + + var clientOptions = new McpClientOptions { ProtocolVersion = "2026-07-28" }; + clientOptions.Handlers.ElicitationHandler = async (request, ct) => + { + // Signal that the MRTR round trip reached the client, then block indefinitely. + elicitHandlerCalled.TrySetResult(true); + await Task.Delay(Timeout.Infinite, ct); + throw new OperationCanceledException(ct); + }; + + await using var client = await CreateMcpClientForServer(clientOptions); + + // Start the tool call in the background. + using var cts = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken); + cts.CancelAfter(TimeSpan.FromSeconds(30)); + var callTask = client.CallToolAsync("cancellation-test-tool", cancellationToken: cts.Token).AsTask(); + + // Wait for the handler to start on the server. + await _handlerStarted.Task.WaitAsync(TimeSpan.FromSeconds(30), TestContext.Current.CancellationToken); + + // Wait for the MRTR round trip to reach the client's elicitation handler. + await elicitHandlerCalled.Task.WaitAsync(TimeSpan.FromSeconds(30), TestContext.Current.CancellationToken); + + // Dispose the server - HandlerCts.Cancel() should trigger the handler's CancellationToken. + await Server.DisposeAsync(); + + // Verify the handler's CancellationToken was actually cancelled via HandlerCts, + // not just the exchange ResponseTcs.TrySetCanceled(). + await _handlerTokenCancelled.Task.WaitAsync(TimeSpan.FromSeconds(30), TestContext.Current.CancellationToken); + + // The client call should fail (server disposed mid-MRTR). + await Assert.ThrowsAnyAsync(async () => await callTask); + + // Disposing the server while a continuation is suspended should log the cancellation of the + // pending MRTR continuation once at Debug level (this is the only path that reaches the + // continuation-cancellation log now that the HTTP transport no longer supports sessions starting with the + // 2026-07-28 protocol). Poll for the + // async cancellation to propagate through the handler task. + var deadline = DateTime.UtcNow.AddSeconds(30); + while (!MockLoggerProvider.LogMessages.Any(m => m.Message.Contains("pending MRTR continuation")) + && DateTime.UtcNow < deadline) + { + await Task.Delay(50, TestContext.Current.CancellationToken); + } + + var mrtrCancelledLog = MockLoggerProvider.LogMessages + .Where(m => m.Message.Contains("pending MRTR continuation")) + .ToList(); + var log = Assert.Single(mrtrCancelledLog); + Assert.Equal(LogLevel.Debug, log.LogLevel); + Assert.Contains("1", log.Message); + + // The handler's OperationCanceledException must be silently observed during disposal, not + // logged as an error. + Assert.DoesNotContain(MockLoggerProvider.LogMessages, m => + m.LogLevel >= LogLevel.Error && m.Message.Contains("cancellation-test-tool")); + } + + [Fact] + public async Task CancellationNotification_DuringInFlightMrtrRetry_CancelsHandler() + { + // Verify that cancelling the client's CancellationToken while a retry request is in-flight + // sends notifications/cancelled with the retry's request ID, and the server correctly + // routes it to cancel the handler. This proves end-to-end that: + // (a) the client sends the notification with the CURRENT request ID (not the original), + // (b) the server's _handlingRequests lookup finds the retry's CTS, + // (c) the cancellation registration in AwaitMrtrHandlerAsync bridges to handlerCts. + StartServer(); + + var clientOptions = new McpClientOptions { ProtocolVersion = "2026-07-28" }; + clientOptions.Handlers.ElicitationHandler = (request, ct) => + new ValueTask(new ElicitResult { Action = "accept" }); + + await using var client = await CreateMcpClientForServer(clientOptions); + + using var cts = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken); + cts.CancelAfter(TimeSpan.FromSeconds(30)); + var callTask = client.CallToolAsync( + "elicit-then-block-tool", + new Dictionary { ["message"] = "test" }, + cancellationToken: cts.Token).AsTask(); + + // Wait for the handler to resume after ElicitAsync - at this point the retry + // request is in-flight (server is awaiting WhenAny in AwaitMrtrHandlerAsync). + await _handlerResumed.Task.WaitAsync(TimeSpan.FromSeconds(30), TestContext.Current.CancellationToken); + + // Cancel the client's token. The client is inside _sessionHandler.SendRequestAsync + // awaiting the retry response. RegisterCancellation fires and sends + // notifications/cancelled with the retry's request ID. + cts.Cancel(); + + // The call should throw OperationCanceledException. + await Assert.ThrowsAnyAsync(async () => await callTask); + + _messageTracker.AssertMrtrUsed(); + } + + [Fact] + public async Task CancellationNotification_ForExpiredRequestId_DoesNotAffectHandler() + { + // Verify that a stale cancellation notification for the original (now-completed) + // request ID does not interfere with an active MRTR handler. The original request's + // entry was removed from _handlingRequests when it returned InputRequiredResult, so + // the notification should be a no-op. + StartServer(); + + int elicitationCount = 0; + var clientOptions = new McpClientOptions { ProtocolVersion = "2026-07-28" }; + clientOptions.Handlers.ElicitationHandler = (request, ct) => + { + Interlocked.Increment(ref elicitationCount); + return new ValueTask(new ElicitResult { Action = "accept" }); + }; + + await using var client = await CreateMcpClientForServer(clientOptions); + + // Start the double-elicit tool. Between round 1 and round 2, we'll inject a stale + // cancellation notification for a fake (expired) request ID. + var callTask = client.CallToolAsync( + "double-elicit-tool", + cancellationToken: TestContext.Current.CancellationToken).AsTask(); + + // Wait for handler to resume after the first ElicitAsync. + await _handlerResumed.Task.WaitAsync(TimeSpan.FromSeconds(30), TestContext.Current.CancellationToken); + + // Send a stale cancellation notification for a non-existent request ID. + // This simulates a delayed notification for the original request that already completed. + await client.SendMessageAsync(new JsonRpcNotification + { + Method = NotificationMethods.CancelledNotification, + Params = JsonSerializer.SerializeToNode( + new CancelledNotificationParams { RequestId = new RequestId("stale-id-999"), Reason = "stale test" }, + McpJsonUtilities.DefaultOptions), + }, TestContext.Current.CancellationToken); + + // The tool should complete successfully - the stale notification didn't affect it. + var result = await callTask; + Assert.Contains("accept", result.Content.OfType().First().Text); + + _messageTracker.AssertMrtrUsed(); + } + + [Fact] + public async Task DisposeAsync_WaitsForMrtrHandler_BeforeReturning() + { + // Verify that McpServer.DisposeAsync() waits for an MRTR handler to complete + // before returning, similar to RunAsync_WaitsForInFlightHandlersBeforeReturning + // which tests the same invariant for regular request handlers in McpSessionHandler. + StartServer(); + bool handlerCompleted = false; + + var clientOptions = new McpClientOptions { ProtocolVersion = "2026-07-28" }; + clientOptions.Handlers.ElicitationHandler = (request, ct) => + new ValueTask(new ElicitResult { Action = "accept" }); + + await using var client = await CreateMcpClientForServer(clientOptions); + + // Start the tool call that calls ElicitAsync, then blocks on _releaseHandler. + using var cts = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken); + cts.CancelAfter(TimeSpan.FromSeconds(30)); + _ = client.CallToolAsync( + "dispose-wait-tool", + new Dictionary { ["message"] = "dispose-wait-test" }, + cancellationToken: cts.Token); + + // Wait for the handler to resume after ElicitAsync - it's now blocking on _releaseHandler. + await _handlerResumed.Task.WaitAsync(TimeSpan.FromSeconds(30), TestContext.Current.CancellationToken); + + // Dispose the server. The handler is still running (blocked on _releaseHandler). + // Release the handler after a delay - DisposeAsync must wait for it. + var ct = TestContext.Current.CancellationToken; + _ = Task.Run(async () => + { + await Task.Delay(200, ct); + handlerCompleted = true; + _releaseHandler.SetResult(true); + }, ct); + + await Server.DisposeAsync(); + + // DisposeAsync should not have returned until the handler completed. + Assert.True(handlerCompleted, "DisposeAsync should wait for MRTR handlers to complete before returning."); + + _messageTracker.AssertMrtrUsed(); + } + + [Fact] + public async Task HandlerException_DuringMrtr_IsLoggedAtErrorLevel() + { + // Verify that when a tool handler throws an unhandled exception during MRTR + // (after resuming from ElicitAsync), the error is logged at Error level. + StartServer(); + + var clientOptions = new McpClientOptions { ProtocolVersion = "2026-07-28" }; + clientOptions.Handlers.ElicitationHandler = (request, ct) => + new ValueTask(new ElicitResult { Action = "accept" }); + + await using var client = await CreateMcpClientForServer(clientOptions); + + // Call the tool that elicits then throws. The retry returns an error result. + var result = await client.CallToolAsync( + "elicit-then-throw-tool", + cancellationToken: TestContext.Current.CancellationToken); + Assert.True(result.IsError); + + // Verify the tool error was logged at Error level during the MRTR retry. + // The ToolsCall handler catches the exception, logs it via ToolCallError, + // and converts it to an error result - so the error is properly surfaced. + Assert.Contains(MockLoggerProvider.LogMessages, m => + m.LogLevel == LogLevel.Error && + m.Message.Contains("elicit-then-throw-tool") && + m.Exception is InvalidOperationException); + + _messageTracker.AssertMrtrUsed(); + } + + [Fact] + public async Task IncompleteResultException_IsNotLoggedAtErrorLevel() + { + // InputRequiredException is normal MRTR control flow (low-level API), + // not an error. It should not be logged via ToolCallError at Error level. + StartServer(); + + var clientOptions = new McpClientOptions { ProtocolVersion = "2026-07-28" }; + clientOptions.Handlers.ElicitationHandler = (request, ct) => + new ValueTask(new ElicitResult { Action = "accept" }); + + await using var client = await CreateMcpClientForServer(clientOptions); + + // The tool always throws InputRequiredException (low-level MRTR path), + // so the client will retry until hitting the max retry limit. + await Assert.ThrowsAsync(() => client.CallToolAsync( + "incomplete-result-tool", + cancellationToken: TestContext.Current.CancellationToken).AsTask()); + + Assert.DoesNotContain(MockLoggerProvider.LogMessages, m => + m.LogLevel == LogLevel.Error && + m.Exception is InputRequiredException); + + _messageTracker.AssertMrtrUsed(); + } +} diff --git a/tests/ModelContextProtocol.Tests/Server/MrtrInputRequiredExceptionTests.cs b/tests/ModelContextProtocol.Tests/Server/MrtrInputRequiredExceptionTests.cs new file mode 100644 index 000000000..3d927b163 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/MrtrInputRequiredExceptionTests.cs @@ -0,0 +1,148 @@ +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using ModelContextProtocol.Tests.Utils; +using System.Text.Json.Serialization.Metadata; + +namespace ModelContextProtocol.Tests.Server; + +/// +/// Tests for the MRTR server API - IsMrtrSupported, InputRequiredException, +/// and client auto-retry of incomplete results. +/// +public class MrtrInputRequiredExceptionTests : ClientServerTestBase +{ + private readonly ServerMessageTracker _messageTracker = new(); + + public MrtrInputRequiredExceptionTests(ITestOutputHelper testOutputHelper) + : base(testOutputHelper, startServer: false) + { + } + + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + services.Configure(options => + { + options.ProtocolVersion = "2026-07-28"; + _messageTracker.AddFilters(options.Filters.Message); + }); + + mcpServerBuilder.WithTools([ + McpServerTool.Create( + static string (McpServer server) => + { + throw new InputRequiredException(requestState: "should-not-work"); + }, + new McpServerToolCreateOptions + { + Name = "always-incomplete", + Description = "Tool that always throws InputRequiredException" + }), + ]); + } + + [Fact] + public async Task InputRequiredException_WithoutInputRequests_ExhaustsRetries() + { + StartServer(); + var clientOptions = new McpClientOptions(); + + await using var client = await CreateMcpClientForServer(clientOptions); + + // The always-incomplete tool throws InputRequiredException with only requestState + // and no inputRequests. The client has nothing to dispatch, so it keeps retrying + // with the same requestState until the retry budget is exhausted. + var exception = await Assert.ThrowsAsync(() => + client.CallToolAsync("always-incomplete", + cancellationToken: TestContext.Current.CancellationToken).AsTask()); + + Assert.Contains("more than", exception.Message); + } +} + +/// +/// Companion to covering a native (MRTR-capable) round-trip where the +/// server RETURNS an through the alternate result path +/// () rather than throwing . The MRTR +/// client drives the round-trip and receives the final result. +/// +public class MrtrReturnedInputRequiredResultNativeTests : ClientServerTestBase +{ + private static readonly JsonTypeInfo s_inputRequiredResultTypeInfo = + (JsonTypeInfo)McpJsonUtilities.DefaultOptions.GetTypeInfo(typeof(InputRequiredResult)); + + private int _attempt; + + public MrtrReturnedInputRequiredResultNativeTests(ITestOutputHelper testOutputHelper) + : base(testOutputHelper, startServer: false) + { + } + +#pragma warning disable MCPEXP002 // exercises the experimental CallToolWithAlternateHandler/ResultOrAlternate seam + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + services.Configure(options => + { + options.ProtocolVersion = "2026-07-28"; + + options.Handlers.CallToolWithAlternateHandler = (context, cancellationToken) => + { + Interlocked.Increment(ref _attempt); + + // Retry round: the MRTR client re-sent the request with its responses and our requestState. + if (context.Params?.RequestState is not null) + { + return new ValueTask>(new CallToolResult + { + Content = [new TextContentBlock { Text = "resolved" }], + }); + } + + // First round: RETURN an InputRequiredResult through the alternate path. An MRTR client + // understands it natively and drives the round-trip. + var inputRequired = new InputRequiredResult + { + InputRequests = new Dictionary + { + ["confirm"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "need-input", + RequestedSchema = new(), + }), + }, + RequestState = "round1", + }; + + return new ValueTask>( + ResultOrAlternate.FromAlternate(inputRequired, s_inputRequiredResultTypeInfo)); + }; + }); + } +#pragma warning restore MCPEXP002 + + [Fact] + public async Task ReturnedInputRequiredResult_MrtrClient_RoundTripsToFinalResult() + { + StartServer(); + + var clientOptions = new McpClientOptions + { + Capabilities = new ClientCapabilities { Elicitation = new() }, + }; + clientOptions.Handlers.ElicitationHandler = (_, _) => + new ValueTask(new ElicitResult { Action = "accept" }); + + await using var client = await CreateMcpClientForServer(clientOptions); + + var result = await client.CallToolAsync( + "return-form", + cancellationToken: TestContext.Current.CancellationToken); + + // Two handler invocations: initial (returned InputRequiredResult) + client-driven retry (final result). + Assert.Equal(2, _attempt); + var content = Assert.Single(result.Content); + Assert.Equal("resolved", Assert.IsType(content).Text); + } +} diff --git a/tests/ModelContextProtocol.Tests/Server/MrtrMessageFilterTests.cs b/tests/ModelContextProtocol.Tests/Server/MrtrMessageFilterTests.cs new file mode 100644 index 000000000..9c83a3306 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/MrtrMessageFilterTests.cs @@ -0,0 +1,149 @@ +using Microsoft.Extensions.AI; +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using ModelContextProtocol.Tests.Utils; +using System.Text.Json; + +namespace ModelContextProtocol.Tests.Server; + +/// +/// Tests that message filters correctly observe MRTR protocol behavior - verifying that +/// InputRequiredResult responses are visible to outgoing filters, and that no legacy +/// elicitation/sampling requests are sent when MRTR is active. +/// +public class MrtrMessageFilterTests : ClientServerTestBase +{ + private readonly ServerMessageTracker _messageTracker = new(); + + public MrtrMessageFilterTests(ITestOutputHelper testOutputHelper) + : base(testOutputHelper, startServer: false) + { + } + + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + services.Configure(options => + { + options.ProtocolVersion = "2026-07-28"; + _messageTracker.AddFilters(options.Filters.Message); + }); + + mcpServerBuilder + .WithTools([ + McpServerTool.Create( + async (string message, McpServer server, CancellationToken ct) => + { + var result = await server.ElicitAsync(new ElicitRequestParams + { + Message = message, + RequestedSchema = new() + }, ct); + + return $"{result.Action}"; + }, + new McpServerToolCreateOptions + { + Name = "elicit-tool", + Description = "A tool that requests elicitation" + }), + McpServerTool.Create( + async (string prompt, McpServer server, CancellationToken ct) => + { + var result = await server.SampleAsync(new CreateMessageRequestParams + { + Messages = [new SamplingMessage { Role = Role.User, Content = [new TextContentBlock { Text = prompt }] }], + MaxTokens = 100 + }, ct); + + return result.Content.OfType().FirstOrDefault()?.Text ?? ""; + }, + new McpServerToolCreateOptions + { + Name = "sample-tool", + Description = "A tool that requests sampling" + }), + ]); + } + + [Fact] + public async Task MrtrActive_NoOldStyleElicitationRequests_SentOverWire() + { + // When both sides are on the experimental protocol, the server should use MRTR + // (InputRequiredResult) instead of sending old-style elicitation/create JSON-RPC requests. + StartServer(); + var clientOptions = new McpClientOptions { ProtocolVersion = "2026-07-28" }; + clientOptions.Handlers.ElicitationHandler = (request, ct) => + { + return new ValueTask(new ElicitResult { Action = "accept" }); + }; + + await using var client = await CreateMcpClientForServer(clientOptions); + Assert.Equal("2026-07-28", client.NegotiatedProtocolVersion); + + var result = await client.CallToolAsync("elicit-tool", + new Dictionary { ["message"] = "test" }, + cancellationToken: TestContext.Current.CancellationToken); + + var content = Assert.Single(result.Content); + Assert.Equal("accept", Assert.IsType(content).Text); + _messageTracker.AssertMrtrUsed(); + } + + [Fact] + public async Task MrtrActive_NoOldStyleSamplingRequests_SentOverWire() + { + StartServer(); + var clientOptions = new McpClientOptions { ProtocolVersion = "2026-07-28" }; + clientOptions.Handlers.SamplingHandler = (request, progress, ct) => + { + var text = request?.Messages[^1].Content.OfType().FirstOrDefault()?.Text; + return new ValueTask(new CreateMessageResult + { + Content = [new TextContentBlock { Text = $"Sampled: {text}" }], + Model = "test-model" + }); + }; + + await using var client = await CreateMcpClientForServer(clientOptions); + Assert.Equal("2026-07-28", client.NegotiatedProtocolVersion); + + var result = await client.CallToolAsync("sample-tool", + new Dictionary { ["prompt"] = "test" }, + cancellationToken: TestContext.Current.CancellationToken); + + var content = Assert.Single(result.Content); + Assert.Equal("Sampled: test", Assert.IsType(content).Text); + _messageTracker.AssertMrtrUsed(); + } + + [Fact] + public async Task OutgoingFilter_SeesIncompleteResultResponse() + { + // Verify that transport middleware can observe the raw InputRequiredResult + // in outgoing JSON-RPC responses (validates MRTR transport visibility). + var sawIncompleteResult = false; + + StartServer(); + var clientOptions = new McpClientOptions { ProtocolVersion = "2026-07-28" }; + clientOptions.Handlers.ElicitationHandler = (request, ct) => + { + // If we reach this handler, it means the client received an InputRequiredResult + // from the server, resolved the elicitation, and is retrying. + sawIncompleteResult = true; + return new ValueTask(new ElicitResult { Action = "accept" }); + }; + + await using var client = await CreateMcpClientForServer(clientOptions); + + await client.CallToolAsync("elicit-tool", + new Dictionary { ["message"] = "test" }, + cancellationToken: TestContext.Current.CancellationToken); + + // The elicitation handler was called, confirming MRTR round-trip occurred + // (InputRequiredResult was sent by server and processed by client). + Assert.True(sawIncompleteResult, "Expected MRTR round-trip with InputRequiredResult"); + _messageTracker.AssertMrtrUsed(); + } +} diff --git a/tests/ModelContextProtocol.Tests/Server/MrtrServerBackcompatTests.cs b/tests/ModelContextProtocol.Tests/Server/MrtrServerBackcompatTests.cs new file mode 100644 index 000000000..3c5a52d92 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/MrtrServerBackcompatTests.cs @@ -0,0 +1,201 @@ +using System.Text.Json; +using System.Text.Json.Serialization.Metadata; +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using ModelContextProtocol.Tests.Utils; + +namespace ModelContextProtocol.Tests.Server; + +/// +/// Tests for the legacy MRTR backcompat resolver in McpServerImpl.InvokeWithInputRequiredResultHandlingAsync. +/// This path runs only when the client did NOT negotiate MRTR (2026-07-28) and the session is stateful, where +/// the server dispatches each input request to the client via standard JSON-RPC and re-invokes the handler +/// with the merged responses. To exercise it the server must NOT pin a protocol version; the client picks +/// a legacy version during initialize negotiation. +/// +public class MrtrServerBackcompatTests : ClientServerTestBase +{ + private readonly List _observedRequestStates = []; + private int _attempt; + + public MrtrServerBackcompatTests(ITestOutputHelper testOutputHelper) + : base(testOutputHelper, startServer: false) + { + } + + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + mcpServerBuilder.WithTools([ + McpServerTool.Create( + (RequestContext context) => + { + var attempt = Interlocked.Increment(ref _attempt); + _observedRequestStates.Add(context.Params?.RequestState); + + return attempt switch + { + // Round 1: caller has no state; emit one and request elicitation. + 1 => throw new InputRequiredException( + inputRequests: new Dictionary + { + ["confirm"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "round1", + RequestedSchema = new() + }) + }, + requestState: "round1"), + // Round 2: deliberately clear the state by passing requestState: null while still + // asking for another elicitation. This exercises the params clone path that + // previously preserved the stale "round1" carry-over from round 1's deep clone. + 2 => throw new InputRequiredException( + inputRequests: new Dictionary + { + ["confirm"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "round2", + RequestedSchema = new() + }) + }, + requestState: null), + // Round 3 (final): report what the handler observed so the test can assert it. + _ => $"final-state:{context.Params?.RequestState ?? ""}", + }; + }, + new McpServerToolCreateOptions + { + Name = "requeststate-transition", + Description = "Tool that transitions requestState from set to null across MRTR rounds." + }), + ]); + } + + [Fact] + public async Task InputRequiredException_TransitioningRequestStateToNull_DoesNotLeakStaleState() + { + StartServer(); + + // Non-MRTR client → server falls into the legacy backcompat resolver path on InputRequiredException. + var clientOptions = new McpClientOptions + { + ProtocolVersion = "2025-06-18", + Capabilities = new ClientCapabilities { Elicitation = new() }, + }; + clientOptions.Handlers.ElicitationHandler = (_, _) => + new ValueTask(new ElicitResult + { + Action = "accept", + Content = new Dictionary + { + ["answer"] = JsonDocument.Parse("\"ok\"").RootElement, + }, + }); + + await using var client = await CreateMcpClientForServer(clientOptions); + + var result = await client.CallToolAsync( + "requeststate-transition", + cancellationToken: TestContext.Current.CancellationToken); + + // Three attempts: round 1 (no state) → round 2 (state="round1") → round 3 (state=null after fix). + // Without the fix, the third observed state would erroneously remain "round1" because the deep-clone + // of the prior request params carried it forward when InputRequiredException.RequestState was null. + Assert.Equal(3, _observedRequestStates.Count); + Assert.Null(_observedRequestStates[0]); + Assert.Equal("round1", _observedRequestStates[1]); + Assert.Null(_observedRequestStates[2]); + + var content = Assert.Single(result.Content); + var text = Assert.IsType(content).Text; + Assert.Equal("final-state:", text); + } +} + +/// +/// Companion to covering the other way a handler can surface an +/// input-required result to a non-MRTR client: by RETURNING an through the +/// alternate result path () instead of throwing +/// . The legacy backcompat resolver must normalize both forms so a non-MRTR +/// stateful client gets the same server-side resolution either way. +/// +public class MrtrReturnedInputRequiredResultBackcompatTests : ClientServerTestBase +{ + private static readonly JsonTypeInfo s_inputRequiredResultTypeInfo = + (JsonTypeInfo)McpJsonUtilities.DefaultOptions.GetTypeInfo(typeof(InputRequiredResult)); + + private int _attempt; + + public MrtrReturnedInputRequiredResultBackcompatTests(ITestOutputHelper testOutputHelper) + : base(testOutputHelper, startServer: false) + { + } + +#pragma warning disable MCPEXP002 // exercises the experimental CallToolWithAlternateHandler/ResultOrAlternate seam + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + mcpServerBuilder.Services.Configure(options => + { + options.Handlers.CallToolWithAlternateHandler = (context, cancellationToken) => + { + Interlocked.Increment(ref _attempt); + + // Retry round: the backcompat resolver re-invoked us with the client's responses. + if (context.Params?.RequestState is not null) + { + return new ValueTask>(new CallToolResult + { + Content = [new TextContentBlock { Text = "resolved" }], + }); + } + + // First round: RETURN an InputRequiredResult through the alternate path rather than throwing. + var inputRequired = new InputRequiredResult + { + InputRequests = new Dictionary + { + ["confirm"] = InputRequest.ForElicitation(new ElicitRequestParams + { + Message = "need-input", + RequestedSchema = new(), + }), + }, + RequestState = "round1", + }; + + return new ValueTask>( + ResultOrAlternate.FromAlternate(inputRequired, s_inputRequiredResultTypeInfo)); + }; + }); + } +#pragma warning restore MCPEXP002 + + [Fact] + public async Task ReturnedInputRequiredResult_NonMrtrStatefulClient_ResolvedServerSide() + { + StartServer(); + + // Non-MRTR client → server falls into the legacy backcompat resolver path, which must handle a + // RETURNED InputRequiredResult exactly like a thrown InputRequiredException. + var clientOptions = new McpClientOptions + { + ProtocolVersion = "2025-06-18", + Capabilities = new ClientCapabilities { Elicitation = new() }, + }; + clientOptions.Handlers.ElicitationHandler = (_, _) => + new ValueTask(new ElicitResult { Action = "accept" }); + + await using var client = await CreateMcpClientForServer(clientOptions); + + var result = await client.CallToolAsync( + "return-form", + cancellationToken: TestContext.Current.CancellationToken); + + // Two handler invocations: initial (returned InputRequiredResult) + retry (final result). + Assert.Equal(2, _attempt); + var content = Assert.Single(result.Content); + Assert.Equal("resolved", Assert.IsType(content).Text); + } +} diff --git a/tests/ModelContextProtocol.Tests/Server/MrtrSessionLimitTests.cs b/tests/ModelContextProtocol.Tests/Server/MrtrSessionLimitTests.cs new file mode 100644 index 000000000..fc9c26fc2 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/MrtrSessionLimitTests.cs @@ -0,0 +1,183 @@ +using Microsoft.Extensions.AI; +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using ModelContextProtocol.Tests.Utils; +using System.Collections.Concurrent; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.Tests.Server; + +/// +/// Tests for session-scoped MRTR resource governance - verifying that outgoing message +/// filters can track and limit MRTR round trips per session. +/// +public class MrtrSessionLimitTests : ClientServerTestBase +{ + /// + /// Tracks the number of pending MRTR flows per session. Incremented when an InputRequiredResult + /// is sent (outgoing filter), decremented when a retry with requestState arrives (incoming filter). + /// + private readonly ConcurrentDictionary _pendingFlowsPerSession = new(); + + /// + /// Records every (sessionId, pendingCount) observation from the outgoing filter, + /// so the test can verify the tracking was correct. + /// + private readonly ConcurrentBag<(string SessionId, int PendingCount)> _observations = []; + + private readonly ServerMessageTracker _messageTracker = new(); + + /// + /// Maximum allowed concurrent MRTR flows per session. If exceeded, the outgoing filter + /// replaces the InputRequiredResult with an error response. + /// + private int _maxFlowsPerSession = int.MaxValue; + + /// + /// Counts how many IncompleteResults were blocked by the per-session limit. + /// + private int _blockedFlowCount; + + public MrtrSessionLimitTests(ITestOutputHelper testOutputHelper) + : base(testOutputHelper, startServer: false) + { + } + + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + services.Configure(options => + { + options.ProtocolVersion = "2026-07-28"; + _messageTracker.AddFilters(options.Filters.Message); + + // Outgoing filter: detect InputRequiredResult responses and track per session. + options.Filters.Message.OutgoingFilters.Add(next => async (context, cancellationToken) => + { + if (context.JsonRpcMessage is JsonRpcResponse response && + response.Result is JsonObject resultObj && + resultObj.TryGetPropertyValue("resultType", out var resultTypeNode) && + resultTypeNode?.GetValue() is "input_required") + { + var sessionId = context.Server.SessionId ?? "unknown"; + var newCount = _pendingFlowsPerSession.AddOrUpdate(sessionId, 1, (_, c) => c + 1); + _observations.Add((sessionId, newCount)); + + // Enforce per-session limit: if exceeded, replace the InputRequiredResult + // with a JSON-RPC error. This prevents the client from receiving the + // InputRequiredResult and starting another retry cycle. + if (newCount > _maxFlowsPerSession) + { + // Undo the increment since we're blocking this flow. + _pendingFlowsPerSession.AddOrUpdate(sessionId, 0, (_, c) => Math.Max(0, c - 1)); + Interlocked.Increment(ref _blockedFlowCount); + + // Replace the outgoing message with a JSON-RPC error. + context.JsonRpcMessage = new JsonRpcError + { + Id = response.Id, + Error = new JsonRpcErrorDetail + { + Code = (int)McpErrorCode.InvalidRequest, + Message = $"Too many pending MRTR flows for this session (limit: {_maxFlowsPerSession}).", + } + }; + } + } + + await next(context, cancellationToken); + }); + + // Incoming filter: detect retries (requests with requestState) and decrement. + options.Filters.Message.IncomingFilters.Add(next => async (context, cancellationToken) => + { + if (context.JsonRpcMessage is JsonRpcRequest request && + request.Params is JsonObject paramsObj && + paramsObj.TryGetPropertyValue("requestState", out var stateNode) && + stateNode is not null) + { + var sessionId = context.Server.SessionId ?? "unknown"; + _pendingFlowsPerSession.AddOrUpdate(sessionId, 0, (_, c) => Math.Max(0, c - 1)); + } + + await next(context, cancellationToken); + }); + }); + + mcpServerBuilder.WithTools([ + McpServerTool.Create( + async (string message, McpServer server, CancellationToken ct) => + { + var result = await server.ElicitAsync(new ElicitRequestParams + { + Message = message, + RequestedSchema = new() + }, ct); + + return $"{result.Action}"; + }, + new McpServerToolCreateOptions + { + Name = "elicit-tool", + Description = "A tool that requests elicitation" + }), + ]); + } + + [Fact] + public async Task OutgoingFilter_TracksIncompleteResultsPerSession() + { + // Verify that an outgoing message filter can observe InputRequiredResult responses + // and track the pending MRTR flow count per session using context.Server.SessionId. + StartServer(); + var clientOptions = new McpClientOptions { ProtocolVersion = "2026-07-28" }; + clientOptions.Handlers.ElicitationHandler = (request, ct) => + new ValueTask(new ElicitResult { Action = "accept" }); + + await using var client = await CreateMcpClientForServer(clientOptions); + + // Call the tool - triggers one MRTR round-trip. + var result = await client.CallToolAsync("elicit-tool", + new Dictionary { ["message"] = "confirm?" }, + cancellationToken: TestContext.Current.CancellationToken); + + Assert.Equal("accept", Assert.IsType(Assert.Single(result.Content)).Text); + + // Verify the filter observed exactly one InputRequiredResult and tracked it. + Assert.Single(_observations); + var (sessionId, pendingCount) = _observations.First(); + Assert.NotNull(sessionId); + Assert.Equal(1, pendingCount); + + // After the retry completed, the count should be back to 0. + Assert.Equal(0, _pendingFlowsPerSession.GetValueOrDefault(sessionId)); + + _messageTracker.AssertMrtrUsed(); + } + + [Fact] + public async Task OutgoingFilter_CanEnforcePerSessionMrtrLimit() + { + // Verify that an outgoing message filter can enforce a per-session MRTR flow limit + // by replacing the InputRequiredResult with a JSON-RPC error when the limit is exceeded. + // Set the limit to 0 so the very first MRTR flow is blocked. + _maxFlowsPerSession = 0; + + StartServer(); + var clientOptions = new McpClientOptions { ProtocolVersion = "2026-07-28" }; + clientOptions.Handlers.ElicitationHandler = (request, ct) => + new ValueTask(new ElicitResult { Action = "accept" }); + + await using var client = await CreateMcpClientForServer(clientOptions); + + // The tool call should fail because the outgoing filter blocks the InputRequiredResult. + var ex = await Assert.ThrowsAsync(async () => + await client.CallToolAsync("elicit-tool", + new Dictionary { ["message"] = "confirm?" }, + cancellationToken: TestContext.Current.CancellationToken)); + + Assert.Contains("Too many pending MRTR flows", ex.Message); + Assert.Equal(1, _blockedFlowCount); + } +} diff --git a/tests/ModelContextProtocol.Tests/Server/NegotiatedProtocolVersionTests.cs b/tests/ModelContextProtocol.Tests/Server/NegotiatedProtocolVersionTests.cs new file mode 100644 index 000000000..d8cadeb61 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/NegotiatedProtocolVersionTests.cs @@ -0,0 +1,358 @@ +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using ModelContextProtocol.Tests.Utils; +using System.ComponentModel; +using System.IO.Pipelines; +using System.Text.Json; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.Tests.Server; + +/// +/// Verifies the server establishes its negotiated protocol version exactly once per stateful session: the +/// initial -to-value transition is allowed and re-sending the same version is an +/// idempotent no-op, but a request that switches to a different (even if otherwise supported) version is +/// rejected with . The session is driven over a raw stream +/// transport (the stdio-shaped, stateful path) so the per-request _meta protocol version is fully +/// controlled - the SDK's own client normalizes it on every outgoing request, so only a misbehaving peer +/// can trigger a mid-session change. +/// +public sealed class NegotiatedProtocolVersionTests : LoggedTest, IAsyncDisposable +{ + private readonly Pipe _clientToServer = new(); + private readonly Pipe _serverToClient = new(); + private readonly CancellationTokenSource _cts = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken); + private readonly ServiceProvider _services; + private readonly Task _serverTask; + private readonly StreamWriter _writer; + private readonly StreamReader _reader; + + public NegotiatedProtocolVersionTests(ITestOutputHelper testOutputHelper) + : base(testOutputHelper) + { + var serviceCollection = new ServiceCollection(); + serviceCollection.AddLogging(); + serviceCollection.AddSingleton(XunitLoggerProvider); + serviceCollection + .AddMcpServer() + .WithStreamServerTransport(_clientToServer.Reader.AsStream(), _serverToClient.Writer.AsStream()) + .WithTools(); + + _services = serviceCollection.BuildServiceProvider(validateScopes: true); + var server = _services.GetRequiredService(); + _serverTask = server.RunAsync(_cts.Token); + + _writer = new StreamWriter(_clientToServer.Writer.AsStream()) { AutoFlush = true }; + _reader = new StreamReader(_serverToClient.Reader.AsStream()); + } + + [Fact] + public async Task PerRequestProtocolVersion_IsEstablishedOnce_AndRejectsLaterChange() + { + var ct = TestContext.Current.CancellationToken; + + // The first request establishes the 2026-07-28 version for the stateful session (null -> 2026-07-28). + Assert.IsType(await RoundTripAsync(id: 1, McpProtocolVersions.July2026ProtocolVersion, ct)); + + // Re-sending the same version is an idempotent no-op, not an error. + Assert.IsType(await RoundTripAsync(id: 2, McpProtocolVersions.July2026ProtocolVersion, ct)); + + // Switching to a different (still-supported) version mid-session is rejected. + var error = Assert.IsType(await RoundTripAsync(id: 3, McpProtocolVersions.November2025ProtocolVersion, ct)); + Assert.Equal((int)McpErrorCode.InvalidRequest, error.Error.Code); + Assert.Contains("protocol version cannot change", error.Error.Message, StringComparison.OrdinalIgnoreCase); + + // The rejected request must not have mutated the negotiated version: the original 2026-07-28 version still works. + Assert.IsType(await RoundTripAsync(id: 4, McpProtocolVersions.July2026ProtocolVersion, ct)); + } + + [Fact] + public async Task PerRequestMetadata_RejectsInitializeHandshakeVersionBeforeInitialize() + { + var ct = TestContext.Current.CancellationToken; + + var error = Assert.IsType(await RoundTripAsync(id: 1, McpProtocolVersions.November2025ProtocolVersion, ct)); + Assert.Equal((int)McpErrorCode.UnsupportedProtocolVersion, error.Error.Code); + Assert.Contains("initialize", error.Error.Message, StringComparison.OrdinalIgnoreCase); + + // The rejected initialize-handshake _meta request must not have established session state. + Assert.IsType(await RoundTripAsync(id: 2, McpProtocolVersions.July2026ProtocolVersion, ct)); + } + + [Fact] + public async Task PerRequestMetadata_ServesRequestMissingClientInfo() + { + var ct = TestContext.Current.CancellationToken; + + // clientInfo is optional: a request whose _meta omits it is served. + var response = await RoundTripAsync( + id: 1, + McpProtocolVersions.July2026ProtocolVersion, + ct, + includeClientInfo: false); + + Assert.IsType(response); + } + + [Fact] + public async Task PerRequestMetadata_RejectsRequestMissingClientCapabilities() + { + var ct = TestContext.Current.CancellationToken; + + var error = Assert.IsType( + await RoundTripAsync( + id: 1, + McpProtocolVersions.July2026ProtocolVersion, + ct, + includeClientCapabilities: false)); + + Assert.Equal((int)McpErrorCode.InvalidParams, error.Error.Code); + Assert.Contains(MetaKeys.ClientCapabilities, error.Error.Message, StringComparison.Ordinal); + } + + [Fact] + public async Task ServerDiscover_WithoutPerRequestMetadata_IsRejectedBeforeInitialize() + { + var ct = TestContext.Current.CancellationToken; + + var request = new JsonRpcRequest + { + Id = new RequestId(1), + Method = RequestMethods.ServerDiscover, + Params = new JsonObject(), + }; + + var error = Assert.IsType(await SendAndReceiveAsync(request, ct)); + Assert.Equal((int)McpErrorCode.InvalidParams, error.Error.Code); + Assert.Contains(RequestMethods.ServerDiscover, error.Error.Message, StringComparison.Ordinal); + } + + [Fact] + public async Task Initialize_WithPerRequestMetadataProtocolVersion_IsRejected() + { + var ct = TestContext.Current.CancellationToken; + + var error = Assert.IsType( + await RoundTripInitializeAsync(id: 1, McpProtocolVersions.July2026ProtocolVersion, ct)); + + Assert.Equal((int)McpErrorCode.UnsupportedProtocolVersion, error.Error.Code); + Assert.Contains("initialize", error.Error.Message, StringComparison.OrdinalIgnoreCase); + } + + [Fact] + public async Task Initialize_WithReservedPerRequestMetadata_IsRejected() + { + var ct = TestContext.Current.CancellationToken; + + var request = new JsonRpcRequest + { + Id = new RequestId(1), + Method = RequestMethods.Initialize, + Params = JsonSerializer.SerializeToNode(new InitializeRequestParams + { + ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion, + Capabilities = new ClientCapabilities(), + ClientInfo = new Implementation { Name = "test-client", Version = "1.0.0" }, + Meta = new JsonObject + { + [MetaKeys.ClientInfo] = new JsonObject + { + ["name"] = "per-request-meta-client", + ["version"] = "1.0.0", + }, + }, + }, McpJsonUtilities.DefaultOptions), + }; + + var error = Assert.IsType(await SendAndReceiveAsync(request, ct)); + Assert.Equal((int)McpErrorCode.InvalidRequest, error.Error.Code); + Assert.Contains(MetaKeys.ClientInfo, error.Error.Message, StringComparison.Ordinal); + } + + [Fact] + public async Task SubscriptionsListen_WithInitializeProtocolVersion_IsRejected() + { + var ct = TestContext.Current.CancellationToken; + + Assert.IsType( + await RoundTripInitializeAsync(id: 1, McpProtocolVersions.November2025ProtocolVersion, ct)); + + var request = new JsonRpcRequest + { + Id = new RequestId(2), + Method = RequestMethods.SubscriptionsListen, + Params = new JsonObject(), + }; + + var error = Assert.IsType(await SendAndReceiveAsync(request, ct)); + Assert.Equal((int)McpErrorCode.MethodNotFound, error.Error.Code); + Assert.Contains(RequestMethods.SubscriptionsListen, error.Error.Message, StringComparison.Ordinal); + } + + [Theory] + [InlineData("initialize")] + [InlineData("ping")] + [InlineData("logging/setLevel")] + [InlineData("resources/subscribe")] + [InlineData("resources/unsubscribe")] + public async Task RemovedMethod_WithPerRequestMetadataProtocolVersion_IsRejected(string method) + { + var ct = TestContext.Current.CancellationToken; + + var request = new JsonRpcRequest + { + Id = new RequestId(1), + Method = method, + Params = new JsonObject + { + ["_meta"] = PerRequestMetadata(), + }, + }; + + var error = Assert.IsType(await SendAndReceiveAsync(request, ct)); + Assert.Equal((int)McpErrorCode.MethodNotFound, error.Error.Code); + Assert.Contains(method, error.Error.Message, StringComparison.Ordinal); + } + + private async Task RoundTripAsync( + long id, + string protocolVersion, + CancellationToken cancellationToken, + bool includeClientInfo = true, + bool includeClientCapabilities = true) + { + // tools/list is available under both the initialize-handshake and 2026-07-28 revisions (unlike ping/initialize, + // which the 2026-07-28 protocol removed), so it exercises the version guard rather than the + // per-method availability gate. + var meta = new JsonObject + { + [MetaKeys.ProtocolVersion] = protocolVersion, + }; + + if (McpProtocolVersions.RequiresPerRequestMetadata(protocolVersion)) + { + if (includeClientInfo) + { + meta[MetaKeys.ClientInfo] = new JsonObject + { + ["name"] = "test-client", + ["version"] = "1.0.0", + }; + } + + if (includeClientCapabilities) + { + meta[MetaKeys.ClientCapabilities] = new JsonObject(); + } + } + + var request = new JsonRpcRequest + { + Id = new RequestId(id), + Method = RequestMethods.ToolsList, + Params = new JsonObject + { + ["_meta"] = meta, + }, + }; + + return await SendAndReceiveAsync(request, cancellationToken); + } + + private static JsonObject PerRequestMetadata() => new() + { + [MetaKeys.ProtocolVersion] = McpProtocolVersions.July2026ProtocolVersion, + [MetaKeys.ClientInfo] = new JsonObject + { + ["name"] = "test-client", + ["version"] = "1.0.0", + }, + [MetaKeys.ClientCapabilities] = new JsonObject(), + }; + + private async Task RoundTripInitializeAsync(long id, string protocolVersion, CancellationToken cancellationToken) + { + var request = new JsonRpcRequest + { + Id = new RequestId(id), + Method = RequestMethods.Initialize, + Params = JsonSerializer.SerializeToNode(new InitializeRequestParams + { + ProtocolVersion = protocolVersion, + Capabilities = new ClientCapabilities(), + ClientInfo = new Implementation { Name = "test-client", Version = "1.0.0" }, + }, McpJsonUtilities.DefaultOptions), + }; + + return await SendAndReceiveAsync(request, cancellationToken); + } + + private async Task SendAndReceiveAsync(JsonRpcRequest request, CancellationToken cancellationToken) + { + string json = JsonSerializer.Serialize(request, McpJsonUtilities.DefaultOptions.GetTypeInfo(typeof(JsonRpcMessage))); +#if NET + await _writer.WriteLineAsync(json.AsMemory(), cancellationToken); +#else + cancellationToken.ThrowIfCancellationRequested(); + await _writer.WriteLineAsync(json); +#endif + + while (true) + { +#if NET + string? line = await _reader.ReadLineAsync(cancellationToken) + .AsTask() + .WaitAsync(TestConstants.DefaultTimeout, cancellationToken); +#else + string? line = await _reader.ReadLineAsync() + .WaitAsync(TestConstants.DefaultTimeout, cancellationToken); +#endif + + if (line is null) + { + throw new InvalidOperationException("Server stream closed before responding."); + } + + if (string.IsNullOrWhiteSpace(line)) + { + continue; + } + + var message = (JsonRpcMessage)JsonSerializer.Deserialize(line, McpJsonUtilities.DefaultOptions.GetTypeInfo(typeof(JsonRpcMessage)))!; + + // Ignore anything that isn't the response to the request we just sent (e.g. notifications). + if (message is JsonRpcMessageWithId withId && withId.Id.Equals(request.Id)) + { + return message; + } + } + } + + public async ValueTask DisposeAsync() + { + await _cts.CancelAsync(); + _clientToServer.Writer.Complete(); + _serverToClient.Writer.Complete(); + + try + { + await _serverTask; + } + catch (OperationCanceledException) + { + } + + await _services.DisposeAsync(); + _cts.Dispose(); + Dispose(); + } + + [McpServerToolType] + private sealed class EchoTools + { + [McpServerTool, Description("Echoes the input back to the caller.")] + public static string Echo([Description("The message to echo.")] string message) => message; + } +} diff --git a/tests/ModelContextProtocol.Tests/Server/PingProtocolGatingTests.cs b/tests/ModelContextProtocol.Tests/Server/PingProtocolGatingTests.cs new file mode 100644 index 000000000..d5735f105 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/PingProtocolGatingTests.cs @@ -0,0 +1,53 @@ +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; + +namespace ModelContextProtocol.Tests.Server; + +/// +/// Verifies that the built-in ping handler is gated by protocol version. +/// SEP-2575 (the 2026-07-28 revision) removes ping; servers must +/// respond with -32601 MethodNotFound. Initialize-handshake protocol +/// versions still support ping per the spec. +/// +public sealed class PingProtocolGatingTests : ClientServerTestBase +{ + public PingProtocolGatingTests(ITestOutputHelper testOutputHelper) + : base(testOutputHelper, startServer: false) + { + } + + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + } + + [Fact] + public async Task Ping_OnJuly2026ProtocolSession_ReturnsMethodNotFound() + { + StartServer(); + await using var client = await CreateMcpClientForServer(new McpClientOptions + { + ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion, + }); + + var ex = await Assert.ThrowsAsync(async () => + await client.PingAsync(cancellationToken: TestContext.Current.CancellationToken)); + + Assert.Equal(McpErrorCode.MethodNotFound, ex.ErrorCode); + } + + [Fact] + public async Task Ping_OnInitializeHandshakeSession_StillSucceeds() + { + // Default server config; client pinned to 2025-11-25. + StartServer(); + await using var client = await CreateMcpClientForServer(new McpClientOptions + { + ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion, + }); + + var result = await client.PingAsync(cancellationToken: TestContext.Current.CancellationToken); + Assert.NotNull(result); + } +} diff --git a/tests/ModelContextProtocol.Tests/Server/ProtocolVersionResultDecorationTests.cs b/tests/ModelContextProtocol.Tests/Server/ProtocolVersionResultDecorationTests.cs new file mode 100644 index 000000000..db0f658d7 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/ProtocolVersionResultDecorationTests.cs @@ -0,0 +1,112 @@ +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; + +namespace ModelContextProtocol.Tests.Server; + +/// +/// Regression tests for issue #1721: the SDK-provided resultType, ttlMs, and +/// cacheScope result decorations are exclusive to the 2026-07-28 protocol revision and +/// must be absent from result objects on a session negotiated to an earlier revision +/// (e.g. 2025-11-25). Emitting them breaks clients that strictly validate the 2025-11-25 +/// schema. +/// +/// +/// These drive the in-process client/server pair and inspect the +/// raw JSON-RPC result wire shape (via ) +/// so the assertions are about the actual serialized fields rather than deserialized objects. +/// tools/list exercises the SetHandler decoration path (its result is both an +/// and a ), while tools/call exercises the +/// SetWithAlternateHandler path. +/// +public class ProtocolVersionResultDecorationTests : ClientServerTestBase +{ + public ProtocolVersionResultDecorationTests(ITestOutputHelper testOutputHelper) + : base(testOutputHelper) + { + } + + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + mcpServerBuilder.WithTools([McpServerTool.Create(() => "ok", new() { Name = "echo" })]); + } + + [Fact] + public async Task ToolsList_On2025_11_25Session_OmitsResultTypeAndCacheHints() + { + await using var client = await CreateMcpClientForServer( + new McpClientOptions { ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion }); + + Assert.Equal(McpProtocolVersions.November2025ProtocolVersion, client.NegotiatedProtocolVersion); + + var response = await client.SendRequestAsync( + new JsonRpcRequest { Method = RequestMethods.ToolsList }, + TestContext.Current.CancellationToken); + + var result = response.Result!.AsObject(); + Assert.False(result.ContainsKey("resultType"), "resultType must be absent on a 2025-11-25 tools/list result."); + Assert.False(result.ContainsKey("ttlMs"), "ttlMs must be absent on a 2025-11-25 tools/list result."); + Assert.False(result.ContainsKey("cacheScope"), "cacheScope must be absent on a 2025-11-25 tools/list result."); + } + + [Fact] + public async Task ToolsCall_On2025_11_25Session_OmitsResultType() + { + await using var client = await CreateMcpClientForServer( + new McpClientOptions { ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion }); + + Assert.Equal(McpProtocolVersions.November2025ProtocolVersion, client.NegotiatedProtocolVersion); + + var response = await client.SendRequestAsync( + new JsonRpcRequest + { + Method = RequestMethods.ToolsCall, + Params = System.Text.Json.JsonSerializer.SerializeToNode( + new CallToolRequestParams { Name = "echo" }, McpJsonUtilities.DefaultOptions), + }, + TestContext.Current.CancellationToken); + + var result = response.Result!.AsObject(); + Assert.False(result.ContainsKey("resultType"), "resultType must be absent on a 2025-11-25 tools/call result."); + } + + [Fact] + public async Task ToolsList_On2026_07_28Session_IncludesResultTypeAndCacheHints() + { + await using var client = await CreateMcpClientForServer( + new McpClientOptions { ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion }); + + Assert.Equal(McpProtocolVersions.July2026ProtocolVersion, client.NegotiatedProtocolVersion); + + var response = await client.SendRequestAsync( + new JsonRpcRequest { Method = RequestMethods.ToolsList }, + TestContext.Current.CancellationToken); + + var result = response.Result!.AsObject(); + Assert.Equal("complete", result["resultType"]!.GetValue()); + Assert.True(result.ContainsKey("ttlMs"), "ttlMs must be present on a 2026-07-28 tools/list result."); + Assert.True(result.ContainsKey("cacheScope"), "cacheScope must be present on a 2026-07-28 tools/list result."); + } + + [Fact] + public async Task ToolsCall_On2026_07_28Session_IncludesResultType() + { + await using var client = await CreateMcpClientForServer( + new McpClientOptions { ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion }); + + Assert.Equal(McpProtocolVersions.July2026ProtocolVersion, client.NegotiatedProtocolVersion); + + var response = await client.SendRequestAsync( + new JsonRpcRequest + { + Method = RequestMethods.ToolsCall, + Params = System.Text.Json.JsonSerializer.SerializeToNode( + new CallToolRequestParams { Name = "echo" }, McpJsonUtilities.DefaultOptions), + }, + TestContext.Current.CancellationToken); + + var result = response.Result!.AsObject(); + Assert.Equal("complete", result["resultType"]!.GetValue()); + } +} diff --git a/tests/ModelContextProtocol.Tests/Server/RawStreamConformanceTests.cs b/tests/ModelContextProtocol.Tests/Server/RawStreamConformanceTests.cs new file mode 100644 index 000000000..c068d227e --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/RawStreamConformanceTests.cs @@ -0,0 +1,190 @@ +#if !NET472 +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using ModelContextProtocol.Tests.Utils; +using System.IO.Pipelines; +using System.Text; +using System.Text.Json; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.Tests.Server; + +/// +/// Wire-format conformance tests for driven directly against the underlying +/// stream — without going through . This exercises the +/// SEP-2575 (no initialize handshake) and SEP-2567 (server/discover, no session id) flows by hand-crafting JSON-RPC +/// messages and asserting on the exact responses the server emits. +/// +/// +/// The tests use a paired the way does, but instead +/// of constructing an McpClient we read and write JSON-RPC envelopes directly. This is the closest +/// approximation we have to a third-party / non-SDK client and is what conformance tooling will exercise. +/// +public sealed class RawStreamConformanceTests : LoggedTest, IAsyncDisposable +{ + + private readonly Pipe _clientToServer = new(); + private readonly Pipe _serverToClient = new(); + private readonly CancellationTokenSource _cts = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken); + private readonly Task _serverTask; + private readonly ServiceProvider _services; + private readonly StreamReader _reader; + private readonly StreamWriter _writer; + + public RawStreamConformanceTests(ITestOutputHelper testOutputHelper) + : base(testOutputHelper) + { + var services = new ServiceCollection(); + services.AddLogging(b => b.AddProvider(XunitLoggerProvider)); + services + .AddMcpServer(options => + { + options.ServerInfo = new Implementation { Name = "raw-conformance-server", Version = "1.0.0" }; + }) + .WithStreamServerTransport(_clientToServer.Reader.AsStream(), _serverToClient.Writer.AsStream()) + .WithTools([ + McpServerTool.Create((string text) => $"echo:{text}", new() { Name = "echo" }), + ]); + + _services = services.BuildServiceProvider(validateScopes: true); + var server = _services.GetRequiredService(); + _serverTask = server.RunAsync(_cts.Token); + + _writer = new StreamWriter(_clientToServer.Writer.AsStream(), new UTF8Encoding(false)) { AutoFlush = true, NewLine = "\n" }; + _reader = new StreamReader(_serverToClient.Reader.AsStream(), Encoding.UTF8); + } + + public async ValueTask DisposeAsync() + { + await _cts.CancelAsync(); + _clientToServer.Writer.Complete(); + _serverToClient.Writer.Complete(); + try { await _serverTask; } catch { /* expected on cancellation */ } + await _services.DisposeAsync(); + _cts.Dispose(); + Dispose(); + } + + private async Task SendAsync(string json) => await _writer.WriteLineAsync(json); + + private async Task ReadAsync() + { + var line = await _reader.ReadLineAsync(_cts.Token).ConfigureAwait(false); + Assert.NotNull(line); + return JsonNode.Parse(line!)!; + } + + private static string July2026ProtocolMetaFragment(string protocolVersion = McpProtocolVersions.July2026ProtocolVersion) => + @"""_meta"":{""io.modelcontextprotocol/protocolVersion"":""" + protocolVersion + + @""",""io.modelcontextprotocol/clientInfo"":{""name"":""raw"",""version"":""1.0""}," + + @"""io.modelcontextprotocol/clientCapabilities"":{}}"; + + [Fact] + public async Task ServerDiscover_ReturnsSupportedVersionsIncludingJuly2026Protocol() + { + await SendAsync(@"{""jsonrpc"":""2.0"",""id"":1,""method"":""server/discover"",""params"":{" + July2026ProtocolMetaFragment() + "}}"); + + var response = await ReadAsync(); + Assert.Equal("2.0", response["jsonrpc"]!.GetValue()); + Assert.Equal(1, response["id"]!.GetValue()); + + var result = response["result"]; + Assert.NotNull(result); + + var supportedVersions = result!["supportedVersions"]!.AsArray() + .Select(n => n!.GetValue()) + .ToList(); + Assert.Contains(McpProtocolVersions.July2026ProtocolVersion, supportedVersions); + + // Capabilities are mandatory in DiscoverResult; server identity is result metadata. + Assert.NotNull(result["capabilities"]); + Assert.Null(result["serverInfo"]); + Assert.Equal("raw-conformance-server", result["_meta"]![MetaKeys.ServerInfo]!["name"]!.GetValue()); + + // Spec PR #2855 makes ttlMs and cacheScope required on DiscoverResult; the server emits the + // safest defaults (immediately stale, not shareable) when the application hasn't customized. + Assert.Equal(JsonValueKind.Number, result["ttlMs"]!.GetValueKind()); + Assert.Equal(0, result["ttlMs"]!.GetValue()); + Assert.Equal("private", result["cacheScope"]!.GetValue()); + } + + [Fact] + public async Task July2026ProtocolToolsCall_WithoutInitialize_Succeeds_WhenFullMetaProvided() + { + // Spec: under SEP-2575 the client may skip server/discover and go straight to a normal RPC, as long + // as every request carries the full _meta envelope with protocolVersion, clientInfo and capabilities. + await SendAsync( + @"{""jsonrpc"":""2.0"",""id"":42,""method"":""tools/call"",""params"":{""name"":""echo"",""arguments"":{""text"":""hello""}," + + July2026ProtocolMetaFragment() + "}}"); + + var response = await ReadAsync(); + Assert.Equal(42, response["id"]!.GetValue()); + var result = response["result"]; + Assert.NotNull(result); + var content = result!["content"]!.AsArray(); + Assert.Single(content); + Assert.Equal("echo:hello", content[0]!["text"]!.GetValue()); + Assert.Equal("raw-conformance-server", result["_meta"]![MetaKeys.ServerInfo]!["name"]!.GetValue()); + } + + [Fact] + public async Task July2026ProtocolRequest_WithUnsupportedProtocolVersion_ReturnsMinus32022WithSupported() + { + // Server should respond with UnsupportedProtocolVersionError (-32022) and a data.supported[] list. + await SendAsync( + @"{""jsonrpc"":""2.0"",""id"":7,""method"":""tools/call"",""params"":{""name"":""echo"",""arguments"":{""text"":""x""}," + + July2026ProtocolMetaFragment("9999-99-99") + "}}"); + + var response = await ReadAsync(); + Assert.Equal(7, response["id"]!.GetValue()); + var error = response["error"]; + Assert.NotNull(error); + Assert.Equal((int)McpErrorCode.UnsupportedProtocolVersion, error!["code"]!.GetValue()); + + var data = error["data"]; + Assert.NotNull(data); + Assert.Equal("9999-99-99", data!["requested"]!.GetValue()); + var supported = data["supported"]!.AsArray().Select(n => n!.GetValue()).ToList(); + Assert.Equal([McpProtocolVersions.July2026ProtocolVersion], supported); + } + + [Fact] + public async Task InitializeHandshake_StillWorks_OnJuly2026ProtocolDefaultServer() + { + // Dual-path: a default server must still accept the initialize handshake from clients that + // don't speak the 2026-07-28 per-request metadata path. + await SendAsync(@"{""jsonrpc"":""2.0"",""id"":1,""method"":""initialize"",""params"":{""protocolVersion"":""2025-11-25"",""capabilities"":{},""clientInfo"":{""name"":""initialize-handshake"",""version"":""1.0""}}}"); + + var response = await ReadAsync(); + Assert.Equal(1, response["id"]!.GetValue()); + var result = response["result"]; + Assert.NotNull(result); + Assert.Equal("2025-11-25", result!["protocolVersion"]!.GetValue()); + Assert.Null(result["_meta"]?[MetaKeys.ServerInfo]); + } + + [Fact] + public async Task MixedSequence_Discover_Then_Initialize_Then_ToolsCall_AllSucceed() + { + // Dual-path servers must accept 2026-07-28 per-request metadata and initialize-handshake traffic + // on the same connection. The exact mix below is what a permissive client running against an unknown + // server would emit while probing. + await SendAsync(@"{""jsonrpc"":""2.0"",""id"":1,""method"":""server/discover"",""params"":{" + July2026ProtocolMetaFragment() + "}}"); + var discover = await ReadAsync(); + Assert.NotNull(discover["result"]); + + await SendAsync(@"{""jsonrpc"":""2.0"",""id"":2,""method"":""initialize"",""params"":{""protocolVersion"":""2025-11-25"",""capabilities"":{},""clientInfo"":{""name"":""initialize-handshake"",""version"":""1.0""}}}"); + var init = await ReadAsync(); + Assert.NotNull(init["result"]); + Assert.Equal("2025-11-25", init["result"]!["protocolVersion"]!.GetValue()); + + await SendAsync(@"{""jsonrpc"":""2.0"",""method"":""notifications/initialized"",""params"":{}}"); + + await SendAsync(@"{""jsonrpc"":""2.0"",""id"":3,""method"":""tools/call"",""params"":{""name"":""echo"",""arguments"":{""text"":""after-init""}}}"); + var call = await ReadAsync(); + Assert.Equal("echo:after-init", call["result"]!["content"]![0]!["text"]!.GetValue()); + } +} +#endif diff --git a/tests/ModelContextProtocol.Tests/Server/ResourceSubscriptionProtocolGatingTests.cs b/tests/ModelContextProtocol.Tests/Server/ResourceSubscriptionProtocolGatingTests.cs new file mode 100644 index 000000000..6024e296a --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/ResourceSubscriptionProtocolGatingTests.cs @@ -0,0 +1,91 @@ +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.ComponentModel; + +namespace ModelContextProtocol.Tests.Server; + +/// +/// Verifies that the legacy resources/subscribe and resources/unsubscribe RPCs are +/// gated by protocol version. SEP-2575 (the 2026-07-28 revision) removes them in favor of +/// subscriptions/listen with resourceSubscriptions; servers must respond with +/// -32601 MethodNotFound. Initialize-handshake protocol versions still support the legacy +/// RPCs per the spec. +/// +public sealed class ResourceSubscriptionProtocolGatingTests : ClientServerTestBase +{ + public ResourceSubscriptionProtocolGatingTests(ITestOutputHelper testOutputHelper) + : base(testOutputHelper, startServer: false) + { + } + + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + mcpServerBuilder.WithResources(); + } + + [McpServerResourceType] + private sealed class SubscribableResources + { + [McpServerResource(UriTemplate = "test://resource/{id}"), Description("A subscribable test resource")] + public static string GetResource(string id) => $"Resource content: {id}"; + } + + [Fact] + public async Task Subscribe_OnJuly2026ProtocolSession_ReturnsMethodNotFound() + { + StartServer(); + await using var client = await CreateMcpClientForServer(new McpClientOptions + { + ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion, + }); + + var ex = await Assert.ThrowsAsync(async () => + await client.SubscribeToResourceAsync( + new SubscribeRequestParams { Uri = "test://resource/1" }, + TestContext.Current.CancellationToken)); + + Assert.Equal(McpErrorCode.MethodNotFound, ex.ErrorCode); + // The rejection must point callers at the SEP-2575 replacement. + Assert.Contains(RequestMethods.SubscriptionsListen, ex.Message, StringComparison.Ordinal); + } + + [Fact] + public async Task Unsubscribe_OnJuly2026ProtocolSession_ReturnsMethodNotFound() + { + StartServer(); + await using var client = await CreateMcpClientForServer(new McpClientOptions + { + ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion, + }); + + var ex = await Assert.ThrowsAsync(async () => + await client.UnsubscribeFromResourceAsync( + new UnsubscribeRequestParams { Uri = "test://resource/1" }, + TestContext.Current.CancellationToken)); + + Assert.Equal(McpErrorCode.MethodNotFound, ex.ErrorCode); + Assert.Contains(RequestMethods.SubscriptionsListen, ex.Message, StringComparison.Ordinal); + } + + [Fact] + public async Task Subscribe_OnInitializeHandshakeSession_StillSucceeds() + { + // Default server config; client pinned to 2025-11-25. + StartServer(); + await using var client = await CreateMcpClientForServer(new McpClientOptions + { + ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion, + }); + + // Should complete without throwing on the initialize-handshake revision. + await client.SubscribeToResourceAsync( + new SubscribeRequestParams { Uri = "test://resource/1" }, + TestContext.Current.CancellationToken); + + await client.UnsubscribeFromResourceAsync( + new UnsubscribeRequestParams { Uri = "test://resource/1" }, + TestContext.Current.CancellationToken); + } +} diff --git a/tests/ModelContextProtocol.Tests/Server/Sep2106ListToolsBackCompatTests.cs b/tests/ModelContextProtocol.Tests/Server/Sep2106ListToolsBackCompatTests.cs new file mode 100644 index 000000000..6ae1ab7a4 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/Sep2106ListToolsBackCompatTests.cs @@ -0,0 +1,406 @@ +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.Text.Json; +using System.Text.Json.Nodes; +using System.Text.Json.Serialization.Metadata; + +namespace ModelContextProtocol.Tests.Server; + +/// +/// SEP-2106 backward-compat at the tools/list emission boundary. Clients negotiating a +/// pre-2026-07-28 protocol version must still receive the legacy +/// {"type":"object","properties":{"result":<schema>},"required":["result"]} +/// envelope for non-object output schemas. In-memory storage stays natural; only the +/// wire emission flips on the negotiated version. +/// +public class Sep2106ListToolsBackCompatTests : ClientServerTestBase +{ + private const string LegacyProtocolVersion = "2025-11-25"; + private const string Sep2106ProtocolVersion = "2026-07-28"; + + public Sep2106ListToolsBackCompatTests(ITestOutputHelper testOutputHelper) + : base(testOutputHelper, startServer: false) + { + } + + [Theory] + [InlineData(LegacyProtocolVersion, true)] + [InlineData(Sep2106ProtocolVersion, false)] + public async Task ListTools_StringTool_WrapsOutputSchemaForLegacyClients(string serverProtocolVersion, bool expectWrapped) + { + ConfigureServerWithTools(serverProtocolVersion); + await using var client = await CreateMcpClientForServer(new() { ProtocolVersion = serverProtocolVersion }); + + JsonElement schema = await GetOutputSchemaAsync(client, "return_string"); + + if (expectWrapped) + { + AssertResultEnvelope(schema, innerType: "string"); + } + else + { + Assert.Equal("string", schema.GetProperty("type").GetString()); + Assert.False(schema.TryGetProperty("properties", out _)); + } + } + + [Theory] + [InlineData(LegacyProtocolVersion, true)] + [InlineData(Sep2106ProtocolVersion, false)] + public async Task ListTools_IntegerTool_WrapsOutputSchemaForLegacyClients(string serverProtocolVersion, bool expectWrapped) + { + ConfigureServerWithTools(serverProtocolVersion); + await using var client = await CreateMcpClientForServer(new() { ProtocolVersion = serverProtocolVersion }); + + JsonElement schema = await GetOutputSchemaAsync(client, "return_int"); + + if (expectWrapped) + { + AssertResultEnvelope(schema, innerType: "integer"); + } + else + { + Assert.Equal("integer", schema.GetProperty("type").GetString()); + } + } + + [Theory] + [InlineData(LegacyProtocolVersion, true)] + [InlineData(Sep2106ProtocolVersion, false)] + public async Task ListTools_ArrayTool_WrapsOutputSchemaForLegacyClients(string serverProtocolVersion, bool expectWrapped) + { + ConfigureServerWithTools(serverProtocolVersion); + await using var client = await CreateMcpClientForServer(new() { ProtocolVersion = serverProtocolVersion }); + + JsonElement schema = await GetOutputSchemaAsync(client, "return_array"); + + if (expectWrapped) + { + AssertResultEnvelope(schema, innerType: "array"); + } + else + { + Assert.Equal("array", schema.GetProperty("type").GetString()); + } + } + + [Theory] + [InlineData(LegacyProtocolVersion)] + [InlineData(Sep2106ProtocolVersion)] + public async Task ListTools_ObjectTool_NeverWrapsOutputSchema(string serverProtocolVersion) + { + // Object-shaped schemas should be wire-identical across all protocol versions. + ConfigureServerWithTools(serverProtocolVersion); + await using var client = await CreateMcpClientForServer(new() { ProtocolVersion = serverProtocolVersion }); + + JsonElement schema = await GetOutputSchemaAsync(client, "return_person"); + + Assert.Equal("object", schema.GetProperty("type").GetString()); + Assert.True(schema.GetProperty("properties").TryGetProperty("name", out _)); + Assert.True(schema.GetProperty("properties").TryGetProperty("age", out _)); + Assert.False(schema.GetProperty("properties").TryGetProperty("result", out _)); + } + + [Theory] + [InlineData(LegacyProtocolVersion, true)] + [InlineData(Sep2106ProtocolVersion, false)] + public async Task ListTools_NullableObjectTool_NormalizesTypeArrayForLegacyClients(string serverProtocolVersion, bool expectNormalized) + { + // For clients on protocol versions older than 2026-07-28, type:["object","null"] + // must be emitted as plain type:"object" (those versions accept object schemas but + // not type-arrays, and the value side stays a plain object, no envelope). SEP-2106 + // clients (2026-07-28+) see the natural type-array intact per the SEP's + // any-JSON-Schema-2020-12 allowance. + ConfigureServerWithTools(serverProtocolVersion); + await using var client = await CreateMcpClientForServer(new() { ProtocolVersion = serverProtocolVersion }); + + JsonElement schema = await GetOutputSchemaAsync(client, "return_nullable_object"); + + Assert.False(schema.GetProperty("properties").TryGetProperty("result", out _), + "type:['object','null'] schemas must not be re-wrapped in a result envelope."); + + JsonElement typeProperty = schema.GetProperty("type"); + if (expectNormalized) + { + // Legacy wire shape: ["object","null"] collapsed to plain "object" string. + Assert.Equal(JsonValueKind.String, typeProperty.ValueKind); + Assert.Equal("object", typeProperty.GetString()); + } + else + { + // SEP-2106 wire shape: the natural type array passes through with both + // members, in either order. + Assert.Equal(JsonValueKind.Array, typeProperty.ValueKind); + Assert.Equal(2, typeProperty.GetArrayLength()); + HashSet members = []; + foreach (JsonElement entry in typeProperty.EnumerateArray()) + { + members.Add(entry.GetString()); + } + Assert.Contains("object", members); + Assert.Contains("null", members); + } + } + + [Theory] + [InlineData(LegacyProtocolVersion, true)] + [InlineData(Sep2106ProtocolVersion, false)] + public async Task ListTools_DuplicateTypeRefsTool_RewritesRefsWhenWrapped(string serverProtocolVersion, bool expectWrapped) + { + // List has the same type (PhoneNumber) at two locations, so the schema + // exporter emits $ref pointers for deduplication. For legacy clients the array schema + // is wrapped under properties.result, which must rewrite those $refs to stay resolvable. + ConfigureServerWithTools(serverProtocolVersion); + await using var client = await CreateMcpClientForServer(new() { ProtocolVersion = serverProtocolVersion }); + + JsonElement schema = await GetOutputSchemaAsync(client, "return_duplicate_refs"); + + AssertRefsValidForWire(schema, expectWrapped); + } + + [Theory] + [InlineData(LegacyProtocolVersion, true)] + [InlineData(Sep2106ProtocolVersion, false)] + public async Task ListTools_RecursiveTypeRefsTool_RewritesRefsWhenWrapped(string serverProtocolVersion, bool expectWrapped) + { + // List is recursive: Children's items emit a $ref back to the TreeNode + // definition (e.g. "#/items"). When wrapped for legacy clients that becomes + // "#/properties/result/items" and must still resolve. + ConfigureServerWithTools(serverProtocolVersion); + await using var client = await CreateMcpClientForServer(new() { ProtocolVersion = serverProtocolVersion }); + + JsonElement schema = await GetOutputSchemaAsync(client, "return_recursive_refs"); + + AssertRefsValidForWire(schema, expectWrapped); + } + + /// + /// Asserts the emitted schema's $ref pointers are consistent with the wire shape: + /// when wrapped (legacy clients) the array schema is enveloped under + /// properties.result and every $ref is rewritten under that prefix; otherwise + /// (SEP-2106 clients) the natural array schema is emitted with its original refs. Either + /// way, every $ref must resolve against the emitted schema root. + /// + private static void AssertRefsValidForWire(JsonElement schema, bool expectWrapped) + { + JsonNode schemaNode = JsonNode.Parse(schema.GetRawText())!; + + if (expectWrapped) + { + Assert.Equal("object", schema.GetProperty("type").GetString()); + int rewritten = AssertAllRefsStartWith(schemaNode, "#/properties/result"); + Assert.True(rewritten > 0, "Expected at least one $ref rewritten under #/properties/result."); + } + else + { + Assert.Equal("array", schema.GetProperty("type").GetString()); + Assert.Equal(0, CountRefsStartingWith(schemaNode, "#/properties/result")); + } + + int resolvable = AssertAllRefsResolvable(schemaNode, schemaNode); + Assert.True(resolvable > 0, "Expected at least one resolvable $ref in the schema."); + } + + private static int AssertAllRefsStartWith(JsonNode? node, string expectedPrefix) + { + int count = 0; + if (node is JsonObject obj) + { + if (obj.TryGetPropertyValue("$ref", out JsonNode? refNode) && + refNode?.GetValue() is string refValue) + { + Assert.StartsWith(expectedPrefix, refValue); + count++; + } + + foreach (var property in obj) + { + count += AssertAllRefsStartWith(property.Value, expectedPrefix); + } + } + else if (node is JsonArray arr) + { + foreach (var item in arr) + { + count += AssertAllRefsStartWith(item, expectedPrefix); + } + } + + return count; + } + + private static int CountRefsStartingWith(JsonNode? node, string prefix) + { + int count = 0; + if (node is JsonObject obj) + { + if (obj.TryGetPropertyValue("$ref", out JsonNode? refNode) && + refNode?.GetValue() is string refValue && + refValue.StartsWith(prefix, StringComparison.Ordinal)) + { + count++; + } + + foreach (var property in obj) + { + count += CountRefsStartingWith(property.Value, prefix); + } + } + else if (node is JsonArray arr) + { + foreach (var item in arr) + { + count += CountRefsStartingWith(item, prefix); + } + } + + return count; + } + + private static int AssertAllRefsResolvable(JsonNode root, JsonNode? node) + { + int count = 0; + if (node is JsonObject obj) + { + if (obj.TryGetPropertyValue("$ref", out JsonNode? refNode) && + refNode?.GetValue() is string refValue && + refValue.StartsWith("#", StringComparison.Ordinal)) + { + var resolved = ResolveJsonPointer(root, refValue); + Assert.True(resolved is not null, $"$ref \"{refValue}\" does not resolve to a valid node in the schema."); + count++; + } + + foreach (var property in obj) + { + count += AssertAllRefsResolvable(root, property.Value); + } + } + else if (node is JsonArray arr) + { + foreach (var item in arr) + { + count += AssertAllRefsResolvable(root, item); + } + } + + return count; + } + + private static JsonNode? ResolveJsonPointer(JsonNode root, string pointer) + { + if (pointer == "#") + { + return root; + } + + if (!pointer.StartsWith("#/", StringComparison.Ordinal)) + { + return null; + } + + JsonNode? current = root; + string[] segments = pointer.Substring(2).Split('/'); + foreach (string segment in segments) + { + if (current is JsonObject obj) + { + if (!obj.TryGetPropertyValue(segment, out current)) + { + return null; + } + } + else if (current is JsonArray arr && int.TryParse(segment, out int index) && index >= 0 && index < arr.Count) + { + current = arr[index]; + } + else + { + return null; + } + } + + return current; + } + + private void ConfigureServerWithTools(string protocolVersion) + { + JsonSerializerOptions serializerOptions = new() + { + TypeInfoResolver = new DefaultJsonTypeInfoResolver(), + PropertyNamingPolicy = JsonNamingPolicy.CamelCase, + }; + JsonElement nullableObjectSchema = JsonDocument.Parse( + """{"type":["object","null"],"properties":{"name":{"type":"string"}}}""").RootElement; + + ServiceCollection.Configure(o => o.ProtocolVersion = protocolVersion); + McpServerBuilder.WithTools( + [ + McpServerTool.Create(() => "hello", new() { Name = "return_string", UseStructuredContent = true, SerializerOptions = serializerOptions }), + McpServerTool.Create(() => 42, new() { Name = "return_int", UseStructuredContent = true, SerializerOptions = serializerOptions }), + McpServerTool.Create(() => new[] { "a", "b" }, new() { Name = "return_array", UseStructuredContent = true, SerializerOptions = serializerOptions }), + McpServerTool.Create(() => new Person("John", 27), new() { Name = "return_person", UseStructuredContent = true, SerializerOptions = serializerOptions }), + McpServerTool.Create(() => new Person("John", 27), new() { Name = "return_nullable_object", UseStructuredContent = true, OutputSchema = nullableObjectSchema, SerializerOptions = serializerOptions }), + McpServerTool.Create(() => new List + { + new() + { + WorkPhones = [new() { Number = "555-0100", Type = "work" }], + HomePhones = [new() { Number = "555-0200", Type = "home" }], + } + }, new() { Name = "return_duplicate_refs", UseStructuredContent = true, SerializerOptions = serializerOptions }), + McpServerTool.Create(() => new List + { + new() { Name = "root", Children = [new() { Name = "child" }] } + }, new() { Name = "return_recursive_refs", UseStructuredContent = true, SerializerOptions = serializerOptions }), + ]); + StartServer(); + } + + private static async Task GetOutputSchemaAsync(McpClient client, string toolName) + { + var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + var tool = tools.Single(t => t.Name == toolName); + Assert.NotNull(tool.ProtocolTool.OutputSchema); + return tool.ProtocolTool.OutputSchema.Value; + } + + private static void AssertResultEnvelope(JsonElement schema, string innerType) + { + Assert.Equal("object", schema.GetProperty("type").GetString()); + + JsonElement properties = schema.GetProperty("properties"); + Assert.True(properties.TryGetProperty("result", out JsonElement inner)); + Assert.Equal(innerType, inner.GetProperty("type").GetString()); + + JsonElement required = schema.GetProperty("required"); + Assert.Equal(JsonValueKind.Array, required.ValueKind); + Assert.Equal(1, required.GetArrayLength()); + Assert.Equal("result", required[0].GetString()); + } + + private sealed record Person(string Name, int Age); + + // ContactInfo has two properties of the same type (PhoneNumber), which makes the schema + // exporter emit $ref pointers for deduplication. + private sealed class PhoneNumber + { + public string? Number { get; set; } + public string? Type { get; set; } + } + + private sealed class ContactInfo + { + public List? WorkPhones { get; set; } + public List? HomePhones { get; set; } + } + + // Recursive type: Children's items emit a $ref back to the TreeNode definition. + private sealed class TreeNode + { + public string? Name { get; set; } + public List? Children { get; set; } + } +} diff --git a/tests/ModelContextProtocol.Tests/Server/SubscriptionsListenHandlerTests.cs b/tests/ModelContextProtocol.Tests/Server/SubscriptionsListenHandlerTests.cs new file mode 100644 index 000000000..81e061945 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/SubscriptionsListenHandlerTests.cs @@ -0,0 +1,278 @@ +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Options; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using ModelContextProtocol.Tests.Utils; +using System.Text.Json; +using System.Text.Json.Nodes; +using System.Threading.Channels; + +namespace ModelContextProtocol.Tests.Server; + +/// +/// Tests for the custom (SEP-2575, issue #1662). +/// A custom handler is a full replacement for the built-in subscriptions/listen handling: it owns the +/// stream, sends the acknowledgement itself, streams application-defined notifications, and receives no +/// automatic */list_changed fan-out. These tests run over the in-memory stream transport exercised by +/// . +/// +public class SubscriptionsListenHandlerTests : ClientServerTestBase +{ + private const string CustomResourceUri = "custom://event/1"; + + // Signalled after the custom handler has sent its acknowledgement and first notification and is waiting + // for cancellation. Lets cancellation tests wait until the handler is actually holding the stream open. + private readonly TaskCompletionSource _handlerHoldingStream = new(TaskCreationOptions.RunContinuationsAsynchronously); + + // Signalled from the custom handler's finally block, proving it observed cancellation and cleaned up. + private readonly TaskCompletionSource _handlerCleanedUp = new(TaskCreationOptions.RunContinuationsAsynchronously); + + public SubscriptionsListenHandlerTests(ITestOutputHelper testOutputHelper) + : base(testOutputHelper) + { + } + + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + // Register a tool so the server advertises tools.listChanged; this lets the replacement test below + // trigger a collection change and prove the built-in fan-out no longer runs for the custom handler. + mcpServerBuilder.WithTools(); + + mcpServerBuilder.WithSubscriptionsListenHandler(async (request, cancellationToken) => + { + var subscriptionId = request.JsonRpcRequest.Id; + + // SEP-2575 requires the acknowledgement to be the first message on the stream. The custom handler + // owns this: it echoes back the requested filters as granted and tags the ack with the id. + var ack = new JsonRpcNotification + { + Method = NotificationMethods.SubscriptionsAcknowledgedNotification, + Params = JsonSerializer.SerializeToNode( + new SubscriptionsAcknowledgedNotificationParams { Notifications = request.Params.Notifications }, + McpJsonUtilities.DefaultOptions), + }; + TagWithSubscriptionId(ack, subscriptionId); + await request.Server.SendMessageAsync(ack, cancellationToken); + + // Stream one application-defined notification the built-in handler could never produce on its own, + // proving the handler drives the stream. Tagged with the same subscription id. + var updated = new JsonRpcNotification + { + Method = NotificationMethods.ResourceUpdatedNotification, + Params = new JsonObject { ["uri"] = CustomResourceUri }, + }; + TagWithSubscriptionId(updated, subscriptionId); + await request.Server.SendMessageAsync(updated, cancellationToken); + + _handlerHoldingStream.TrySetResult(true); + + try + { + // Remain active for the subscription lifetime, exactly like the built-in handler, until the + // request-scoped token is cancelled (notifications/cancelled on stdio, client disconnect on HTTP). + var cancelled = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + using var registration = cancellationToken.Register( + static state => ((TaskCompletionSource)state!).TrySetResult(true), cancelled); + await cancelled.Task; + } + finally + { + _handlerCleanedUp.TrySetResult(true); + } + + return new EmptyResult(); + }); + } + + [Fact] + public async Task CustomHandler_July2026_SendsAcknowledgementThenTaggedNotification() + { + await using McpClient client = await CreateMcpClientForServer(new McpClientOptions + { + ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion, + }); + + // Capture the acknowledgement and the streamed notification on separate channels. Both must arrive + // tagged with the subscription id. The test does not assert cross-notification arrival order because + // the client dispatches incoming messages concurrently (see McpSessionHandler.ProcessMessagesCoreAsync), + // so handler invocation order is not observable; acknowledgement-first is a server-side/wire guarantee. + var ackChannel = Channel.CreateUnbounded(); + var updatedChannel = Channel.CreateUnbounded(); + + await using var ackReg = client.RegisterNotificationHandler(NotificationMethods.SubscriptionsAcknowledgedNotification, + (notification, _) => { ackChannel.Writer.TryWrite(notification); return default; }); + await using var updatedReg = client.RegisterNotificationHandler(NotificationMethods.ResourceUpdatedNotification, + (notification, _) => { updatedChannel.Writer.TryWrite(notification); return default; }); + + using var listenCts = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken); + var listenTask = SendSubscriptionsListenAsync( + client, new SubscriptionsListenNotifications { ResourcesListChanged = true }, listenCts.Token); + + // The acknowledgement carries the subscription id. + var ack = await ackChannel.Reader.ReadAsync(TestContext.Current.CancellationToken); + var subscriptionId = GetSubscriptionId(ack); + Assert.NotNull(subscriptionId); + + // The custom application notification is tagged with the same subscription id. + var updated = await updatedChannel.Reader.ReadAsync(TestContext.Current.CancellationToken); + Assert.Equal(subscriptionId, GetSubscriptionId(updated)); + Assert.Equal(CustomResourceUri, (updated.Params as JsonObject)?["uri"]?.GetValue()); + + await CancelSubscriptionAsync(listenCts, listenTask); + } + + [Fact] + public async Task CustomHandler_ReplacesBuiltIn_SuppressesAutomaticListChangedFanOut() + { + await using McpClient client = await CreateMcpClientForServer(new McpClientOptions + { + ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion, + }); + + var ackChannel = Channel.CreateUnbounded(); + var toolsChannel = Channel.CreateUnbounded(); + + await using var ackReg = client.RegisterNotificationHandler(NotificationMethods.SubscriptionsAcknowledgedNotification, + (notification, _) => { ackChannel.Writer.TryWrite(notification); return default; }); + await using var toolsReg = client.RegisterNotificationHandler(NotificationMethods.ToolListChangedNotification, + (notification, _) => { toolsChannel.Writer.TryWrite(notification); return default; }); + + using var listenCts = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken); + // Request tools/list_changed. The built-in handler would fan these out; the custom handler replaces it + // and never tracks the subscription, so the SDK must deliver nothing automatically for this change. + var listenTask = SendSubscriptionsListenAsync( + client, new SubscriptionsListenNotifications { ToolsListChanged = true }, listenCts.Token); + + // Wait until the custom handler is holding the stream open (ack + first notification already sent). + await _handlerHoldingStream.Task.WaitAsync(TestContext.Current.CancellationToken); + await ackChannel.Reader.ReadAsync(TestContext.Current.CancellationToken); + + // Mutate the tool collection. With the built-in handler this would deliver a tagged tools/list_changed; + // under the custom replacement handler it must not, because _activeSubscriptions is never populated. + // The list-changed fan-out iterates that (empty) set and completes synchronously during Add, so it + // buffers nothing to send. The ListToolsAsync round-trip then flushes the client read pipeline. + var serverOptions = ServiceProvider.GetRequiredService>().Value; + serverOptions.ToolCollection!.Add(McpServerTool.Create([McpServerTool(Name = "AddedTool")] () => "42")); + + await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + await CancelSubscriptionAsync(listenCts, listenTask); + + // Completed-and-empty proves nothing was ever delivered, not merely "nothing buffered right now": + // WaitToReadAsync returns false only when the channel is both empty and completed. + toolsChannel.Writer.Complete(); + Assert.False(await toolsChannel.Reader.WaitToReadAsync(TestContext.Current.CancellationToken)); + } + + [Fact] + public async Task CustomHandler_PreJuly2026_IsRejectedWithMethodNotFound() + { + await using McpClient client = await CreateMcpClientForServer(new McpClientOptions + { + ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion, + }); + + var request = new JsonRpcRequest + { + Method = RequestMethods.SubscriptionsListen, + Params = JsonSerializer.SerializeToNode( + new SubscriptionsListenRequestParams { Notifications = new SubscriptionsListenNotifications { ResourcesListChanged = true } }, + McpJsonUtilities.DefaultOptions), + }; + + var ex = await Assert.ThrowsAsync(() => + client.SendRequestAsync(request, TestContext.Current.CancellationToken)); + + Assert.Equal(McpErrorCode.MethodNotFound, ex.ErrorCode); + } + + [Fact] + public async Task CustomHandler_OnCancellation_ObservesTokenAndCleansUp() + { + await using McpClient client = await CreateMcpClientForServer(new McpClientOptions + { + ProtocolVersion = McpProtocolVersions.July2026ProtocolVersion, + }); + + // Use an explicit request id so the test can address it in a notifications/cancelled message, + // which is the transport-level cancellation signal for a long-lived subscriptions/listen on stdio + // (an HTTP client would instead disconnect, which cancels the same request-scoped token). + var subscriptionId = new RequestId("listen-cancel-1"); + using var listenCts = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken); + var listenTask = SendSubscriptionsListenAsync( + client, new SubscriptionsListenNotifications { ResourcesListChanged = true }, listenCts.Token, subscriptionId); + + // Ensure the handler is actively holding the stream before cancelling. + await _handlerHoldingStream.Task.WaitAsync(TestContext.Current.CancellationToken); + + // Deterministically drive server-side cancellation by sending notifications/cancelled for the request + // id. The server routes this to the request-scoped token the handler is observing. + await client.SendMessageAsync(new JsonRpcNotification + { + Method = NotificationMethods.CancelledNotification, + Params = JsonSerializer.SerializeToNode( + new CancelledNotificationParams { RequestId = subscriptionId }, + McpJsonUtilities.DefaultOptions), + }, TestContext.Current.CancellationToken); + + // The handler observed the token: its cancellation registration ran and its finally block completed. + await _handlerCleanedUp.Task.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); + + // A cancelled request sends no response, so unblock the client side and confirm it observes cancellation. + await CancelSubscriptionAsync(listenCts, listenTask); + } + + private static Task SendSubscriptionsListenAsync( + McpClient client, SubscriptionsListenNotifications notifications, CancellationToken cancellationToken, RequestId requestId = default) + { + var request = new JsonRpcRequest + { + Method = RequestMethods.SubscriptionsListen, + Params = JsonSerializer.SerializeToNode( + new SubscriptionsListenRequestParams { Notifications = notifications }, + McpJsonUtilities.DefaultOptions), + }; + + if (requestId.Id is not null) + { + request.Id = requestId; + } + + return client.SendRequestAsync(request, cancellationToken); + } + + private static async Task CancelSubscriptionAsync(CancellationTokenSource listenCts, Task listenTask) + { + await listenCts.CancelAsync(); + await Assert.ThrowsAnyAsync(() => listenTask); + } + + private static string? GetSubscriptionId(JsonRpcNotification notification) + => ((notification.Params as JsonObject)?["_meta"] as JsonObject)?[MetaKeys.SubscriptionId]?.ToJsonString(); + + private static void TagWithSubscriptionId(JsonRpcNotification notification, RequestId subscriptionId) + { + var paramsObject = notification.Params as JsonObject ?? new JsonObject(); + if (paramsObject["_meta"] is not JsonObject meta) + { + meta = new JsonObject(); + paramsObject["_meta"] = meta; + } + + meta[MetaKeys.SubscriptionId] = subscriptionId.Id switch + { + string stringId => JsonValue.Create(stringId), + long longId => JsonValue.Create(longId), + _ => null, + }; + + notification.Params = paramsObject; + } + + private sealed class ListenTools + { + [McpServerTool, System.ComponentModel.Description("Echoes the input back to the caller.")] + public static string Echo([System.ComponentModel.Description("The message to echo.")] string message) => message; + } +} diff --git a/tests/ModelContextProtocol.Tests/Server/SubscriptionsListenTests.cs b/tests/ModelContextProtocol.Tests/Server/SubscriptionsListenTests.cs new file mode 100644 index 000000000..d727e00f7 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/SubscriptionsListenTests.cs @@ -0,0 +1,161 @@ +using Microsoft.Extensions.AI; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Options; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.ComponentModel; +using System.Text.Json; +using System.Text.Json.Nodes; +using System.Threading.Channels; + +namespace ModelContextProtocol.Tests.Server; + +/// +/// End-to-end tests for the SEP-2575 subscriptions/listen list-changed delivery over an +/// in-memory stream transport (the stdio-shaped path exercised by ). +/// Validates that a client on the 2026-07-28 protocol receives only the change notifications it subscribed to, each tagged +/// with the subscription id, and that initialize-handshake sessions keep receiving the session-wide broadcast. +/// +public class SubscriptionsListenTests : ClientServerTestBase +{ + public SubscriptionsListenTests(ITestOutputHelper testOutputHelper) + : base(testOutputHelper) + { + } + + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + mcpServerBuilder.WithTools(); + mcpServerBuilder.WithPrompts(); + } + + [Fact] + public async Task July2026Protocol_ToolsListChangedSubscription_DeliversTaggedNotification_AndWithholdsUnsubscribed() + { + await using McpClient client = await CreateMcpClientForServer(); + + var ackChannel = Channel.CreateUnbounded(); + var toolsChannel = Channel.CreateUnbounded(); + var promptsChannel = Channel.CreateUnbounded(); + + await using var ackReg = client.RegisterNotificationHandler(NotificationMethods.SubscriptionsAcknowledgedNotification, + (notification, _) => { ackChannel.Writer.TryWrite(notification); return default; }); + await using var toolsReg = client.RegisterNotificationHandler(NotificationMethods.ToolListChangedNotification, + (notification, _) => { toolsChannel.Writer.TryWrite(notification); return default; }); + await using var promptsReg = client.RegisterNotificationHandler(NotificationMethods.PromptListChangedNotification, + (notification, _) => { promptsChannel.Writer.TryWrite(notification); return default; }); + + using var listenCts = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken); + var listenTask = SendSubscriptionsListenAsync(client, new SubscriptionsListenNotifications { ToolsListChanged = true }, listenCts.Token); + + // SEP-2575: the acknowledgement is always sent first, tagged with the subscription id. + var ack = await ackChannel.Reader.ReadAsync(TestContext.Current.CancellationToken); + var subscriptionId = GetSubscriptionId(ack); + Assert.NotNull(subscriptionId); + + var serverOptions = ServiceProvider.GetRequiredService>().Value; + var serverTools = serverOptions.ToolCollection!; + var serverPrompts = serverOptions.PromptCollection!; + + // A prompt change must never reach this client: it only subscribed to tool list changes. Because the + // fan-out skips it without sending anything, the prompts channel stays empty for the rest of the test. + serverPrompts.Add(McpServerPrompt.Create([McpServerPrompt(Name = "AddedPrompt")] () => "added")); + + // A tool change must arrive on the subscription stream, tagged with the same subscription id as the ack. + serverTools.Add(McpServerTool.Create([McpServerTool(Name = "AddedTool")] () => "42")); + var toolsNotification = await toolsChannel.Reader.ReadAsync(TestContext.Current.CancellationToken); + Assert.Equal(subscriptionId, GetSubscriptionId(toolsNotification)); + + // Tear down the open subscription request before the client is disposed. + await CancelSubscriptionAsync(listenCts, listenTask); + + // The prompt change fired before the (delivered) tool change, and notifications arrive in order + // on the subscription stream, so any prompt notification would already be buffered by now. + // Complete the writer and assert the channel drains empty - i.e. nothing was ever delivered, + // not merely "nothing is buffered at this instant". WaitToReadAsync returns false only when the + // channel is both empty and completed; a buffered erroneous notification would make it true. + promptsChannel.Writer.Complete(); + Assert.False(await promptsChannel.Reader.WaitToReadAsync(TestContext.Current.CancellationToken)); + } + + [Fact] + public async Task July2026Protocol_WithoutSubscription_DoesNotBroadcastListChanged() + { + await using McpClient client = await CreateMcpClientForServer(); + + var toolsChannel = Channel.CreateUnbounded(); + await using var toolsReg = client.RegisterNotificationHandler(NotificationMethods.ToolListChangedNotification, + (notification, _) => { toolsChannel.Writer.TryWrite(notification); return default; }); + + var serverOptions = ServiceProvider.GetRequiredService>().Value; + serverOptions.ToolCollection!.Add(McpServerTool.Create([McpServerTool(Name = "AddedTool")] () => "42")); + + // The change notification must not be broadcast to a client on the 2026-07-28 protocol that never opened a + // subscriptions/listen stream. The list-changed handler runs synchronously during Add (before + // the ListTools round-trip below completes), so any erroneous broadcast would already be + // buffered once the round-trip returns. + await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + + // Complete the writer and assert the channel drains empty rather than just checking the current + // buffer: WaitToReadAsync returns false only when the channel is both empty and completed. + toolsChannel.Writer.Complete(); + Assert.False(await toolsChannel.Reader.WaitToReadAsync(TestContext.Current.CancellationToken)); + } + + [Fact] + public async Task InitializeHandshake_ListChanged_IsBroadcast_WithoutSubscription() + { + await using McpClient client = await CreateMcpClientForServer(new McpClientOptions + { + ProtocolVersion = McpProtocolVersions.November2025ProtocolVersion, + }); + + var toolsChannel = Channel.CreateUnbounded(); + await using var toolsReg = client.RegisterNotificationHandler(NotificationMethods.ToolListChangedNotification, + (notification, _) => { toolsChannel.Writer.TryWrite(notification); return default; }); + + var serverOptions = ServiceProvider.GetRequiredService>().Value; + serverOptions.ToolCollection!.Add(McpServerTool.Create([McpServerTool(Name = "AddedTool")] () => "42")); + + // Initialize-handshake sessions keep the session-wide broadcast and the notification carries no subscription id. + var notification = await toolsChannel.Reader.ReadAsync(TestContext.Current.CancellationToken); + Assert.Null(GetSubscriptionId(notification)); + } + + private static Task SendSubscriptionsListenAsync(McpClient client, SubscriptionsListenNotifications notifications, CancellationToken cancellationToken) + { + var request = new JsonRpcRequest + { + Method = RequestMethods.SubscriptionsListen, + Params = JsonSerializer.SerializeToNode( + new SubscriptionsListenRequestParams { Notifications = notifications }, + McpJsonUtilities.DefaultOptions), + }; + + return client.SendRequestAsync(request, cancellationToken); + } + + private static async Task CancelSubscriptionAsync(CancellationTokenSource listenCts, Task listenTask) + { + await listenCts.CancelAsync(); + await Assert.ThrowsAnyAsync(() => listenTask); + } + + private static string? GetSubscriptionId(JsonRpcNotification notification) + => ((notification.Params as JsonObject)?["_meta"] as JsonObject)?[MetaKeys.SubscriptionId]?.ToJsonString(); + + [McpServerToolType] + private sealed class ListenTools + { + [McpServerTool, Description("Echoes the input back to the caller.")] + public static string Echo([Description("The message to echo.")] string message) => message; + } + + [McpServerPromptType] + private sealed class ListenPrompts + { + [McpServerPrompt, Description("A simple prompt.")] + public static ChatMessage Simple() => new(ChatRole.User, "hello"); + } +} diff --git a/tests/ModelContextProtocol.Tests/Server/TaskCallToolFilterCompositionTests.cs b/tests/ModelContextProtocol.Tests/Server/TaskCallToolFilterCompositionTests.cs new file mode 100644 index 000000000..47d532d56 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/TaskCallToolFilterCompositionTests.cs @@ -0,0 +1,332 @@ +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.Extensions.Tasks; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using ModelContextProtocol.Tests.Utils; + +namespace ModelContextProtocol.Tests.Server; + +public class TaskCallToolFilterCompositionTests(ITestOutputHelper testOutputHelper) : ClientServerTestBase(testOutputHelper) +{ + private readonly TaskCompletionSource _continueBackgroundExecution = new(TaskCreationOptions.RunContinuationsAsynchronously); + private readonly TaskCompletionSource _executionCompleted = new(TaskCreationOptions.RunContinuationsAsynchronously); + private readonly TaskCompletionSource _executionScopeDisposed = new(TaskCreationOptions.RunContinuationsAsynchronously); + private int _alternateFilterInvocationCount; + private int _filterInvocationCount; + private string? _matchedPrimitiveId; + private string? _alternateMatchedPrimitiveId; + private string? _throwingAlternateMatchedPrimitiveId; + private RequestContext? _alternateRequestContext; + private RequestContext? _ordinaryRequestContext; + private IServiceProvider? _alternateServicesBeforeNext; + private IServiceProvider? _alternateServicesAfterNext; + + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + services.AddScoped(_ => new ScopedDependency(_executionScopeDisposed)); + + mcpServerBuilder.Services.Configure(options => + { +#pragma warning disable MCPEXP002 // exercises an alternate filter registered before Tasks + options.Filters.Request.CallToolWithAlternateFilters.Add(async (request, next, cancellationToken) => + { + if (request.Params?.Name == "task-filter-tool") + { + _alternateMatchedPrimitiveId = request.MatchedPrimitive?.Id; + _alternateRequestContext = request; + _alternateServicesBeforeNext = request.Services; + var result = await next(request, cancellationToken); + _alternateServicesAfterNext = request.Services; + return result; + } + + return await next(request, cancellationToken); + }); +#pragma warning restore MCPEXP002 + }); + + mcpServerBuilder + .WithTools() + .WithTasks(new InMemoryMcpTaskStore { DefaultPollIntervalMs = 10 }); + + mcpServerBuilder.Services.Configure(options => + { +#pragma warning disable MCPEXP002 // exercises the experimental CallToolWithAlternateFilters seam + options.Filters.Request.CallToolWithAlternateFilters.Add(async (request, next, cancellationToken) => + { + Interlocked.Increment(ref _alternateFilterInvocationCount); + + if (request.Params?.Name is "suppress-flow-direct-tool" or "suppress-flow-task-tool") + { + Task> continuation; + using (ExecutionContext.SuppressFlow()) + { + continuation = Task.Run( + async () => await next(request, cancellationToken).ConfigureAwait(false), + cancellationToken); + } + + return await continuation.ConfigureAwait(false); + } + + if (request.Params?.Name == "alternate-filter-exception-tool") + { + _throwingAlternateMatchedPrimitiveId = request.MatchedPrimitive?.Id; + throw new InvalidOperationException("Alternate filter failure."); + } + + if (request.Params?.Name == "alternate-short-circuit-tool") + { + return new CallToolResult + { + Content = [new TextContentBlock { Text = "short-circuited" }], + }; + } + + if (request.Params?.Name == "replace-jsonrpc-request-tool") + { + request.JsonRpcRequest = new JsonRpcRequest + { + Id = request.JsonRpcRequest.Id, + Method = request.JsonRpcRequest.Method, + }; + } + + if (request.Params?.Name == "replace-request-context-tool") + { + var replacement = new RequestContext( + request.Server, + request.JsonRpcRequest, + request.Params) + { + Services = request.Services, + }; + return await next(replacement, cancellationToken); + } + + if (request.Params?.Name == "alternate-transform-result-tool") + { + _ = await next(request, cancellationToken); + return new CallToolResult + { + IsError = true, + Content = [new TextContentBlock { Text = "transformed" }], + }; + } + + if (request.Params?.Name == "task-filter-tool") + { + return await next(request, cancellationToken); + } + + _alternateMatchedPrimitiveId = request.MatchedPrimitive?.Id; + _alternateRequestContext = request; + _alternateServicesBeforeNext = request.Services; + var result = await next(request, cancellationToken); + _alternateServicesAfterNext = request.Services; + return result; + }); +#pragma warning restore MCPEXP002 + + options.Filters.Request.CallToolFilters.Add(next => async (request, cancellationToken) => + { + if (request.Params?.Name != "task-filter-tool") + { + return await next(request, cancellationToken); + } + + Interlocked.Increment(ref _filterInvocationCount); + _matchedPrimitiveId = request.MatchedPrimitive?.Id; + _ordinaryRequestContext = request; + + try + { + await _continueBackgroundExecution.Task.WaitAsync(TestConstants.DefaultTimeout, cancellationToken); + _ = request.Services!.GetRequiredService(); + var result = await next(request, cancellationToken); + _executionCompleted.TrySetResult(result); + return result; + } + catch (Exception exception) + { + _executionCompleted.TrySetException(exception); + throw; + } + }); + }); + } + + [Fact] + public async Task TaskBackedTool_RunsOrdinaryFilterOnce_InIndependentScope() + { + await using var client = await CreateMcpClientForServer(); + var cancellationToken = TestContext.Current.CancellationToken; + + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "task-filter-tool" }, + cancellationToken); + + Assert.True(augmented.IsTask); + _continueBackgroundExecution.TrySetResult(true); + + var result = await _executionCompleted.Task.WaitAsync(TestConstants.DefaultTimeout, cancellationToken); + Assert.Equal("task filter result", Assert.IsType(Assert.Single(result.Content)).Text); + Assert.Equal(1, _filterInvocationCount); + Assert.Equal("task-filter-tool", _matchedPrimitiveId); + Assert.Equal("task-filter-tool", _alternateMatchedPrimitiveId); + Assert.NotSame(_alternateRequestContext, _ordinaryRequestContext); + Assert.Same(_alternateServicesBeforeNext, _alternateServicesAfterNext); + Assert.True(await _executionScopeDisposed.Task.WaitAsync(TestConstants.DefaultTimeout, cancellationToken)); + + var task = await client.GetTaskAsync(augmented.TaskCreated!.TaskId, cancellationToken); + Assert.IsType(task); + } + + [Fact] + public async Task AlternateFilterException_IsConvertedToCallToolError() + { + await using var client = await CreateMcpClientForServer(); + + var result = await client.CallToolAsync( + "alternate-filter-exception-tool", + cancellationToken: TestContext.Current.CancellationToken); + + Assert.True(result.IsError); + Assert.Equal( + "An error occurred invoking 'alternate-filter-exception-tool'.", + Assert.IsType(Assert.Single(result.Content)).Text); + Assert.Equal("alternate-filter-exception-tool", _throwingAlternateMatchedPrimitiveId); + } + + [Fact] + public async Task AlternateFilterShortCircuit_LogsCompletionOnce() + { + await using var client = await CreateMcpClientForServer(); + + var result = await client.CallToolAsync( + "alternate-short-circuit-tool", + cancellationToken: TestContext.Current.CancellationToken); + + Assert.Equal("short-circuited", Assert.IsType(Assert.Single(result.Content)).Text); + Assert.Single( + MockLoggerProvider.LogMessages, + message => message.Message == "\"alternate-short-circuit-tool\" completed. IsError = False."); + } + + [Fact] + public async Task AlternateInvocationFilter_RunsForEachRequest() + { + await using var client = await CreateMcpClientForServer(); + + await client.CallToolAsync( + "alternate-short-circuit-tool", + cancellationToken: TestContext.Current.CancellationToken); + await client.CallToolAsync( + "alternate-short-circuit-tool", + cancellationToken: TestContext.Current.CancellationToken); + + Assert.Equal(2, _alternateFilterInvocationCount); + } + + [Fact] + public async Task AlternateInvocationFilter_CanSuppressExecutionContextForDirectCall() + { + await using var client = await CreateMcpClientForServer(); + + var result = await client.CallToolAsync( + "suppress-flow-direct-tool", + cancellationToken: TestContext.Current.CancellationToken); + + Assert.Equal("direct succeeded", Assert.IsType(Assert.Single(result.Content)).Text); + } + + [Fact] + public async Task AlternateInvocationFilter_CanSuppressExecutionContextForTaskBackedCall() + { + await using var client = await CreateMcpClientForServer(); + + var result = await client.CallToolWithPollingAsync( + new CallToolRequestParams { Name = "suppress-flow-task-tool" }, + cancellationToken: TestContext.Current.CancellationToken); + + Assert.Equal("task succeeded", Assert.IsType(Assert.Single(result.Content)).Text); + } + + [Fact] + public async Task AlternateFilter_CanReplaceJsonRpcRequest() + { + await using var client = await CreateMcpClientForServer(); + + var result = await client.CallToolAsync( + "replace-jsonrpc-request-tool", + cancellationToken: TestContext.Current.CancellationToken); + + Assert.Equal("replacement succeeded", Assert.IsType(Assert.Single(result.Content)).Text); + } + + [Fact] + public async Task AlternateFilter_CanReplaceRequestContext() + { + await using var client = await CreateMcpClientForServer(); + + var result = await client.CallToolAsync( + "replace-request-context-tool", + cancellationToken: TestContext.Current.CancellationToken); + + Assert.Equal("context replacement succeeded", Assert.IsType(Assert.Single(result.Content)).Text); + } + + [Fact] + public async Task AlternateFilterTransformedResult_LogsFinalResult() + { + await using var client = await CreateMcpClientForServer(); + + var result = await client.CallToolAsync( + "alternate-transform-result-tool", + cancellationToken: TestContext.Current.CancellationToken); + + Assert.True(result.IsError); + Assert.Equal("transformed", Assert.IsType(Assert.Single(result.Content)).Text); + var completionLog = Assert.Single( + MockLoggerProvider.LogMessages, + message => message.Message.StartsWith("\"alternate-transform-result-tool\" completed.", StringComparison.Ordinal)); + Assert.Equal("\"alternate-transform-result-tool\" completed. IsError = True.", completionLog.Message); + } + + private sealed class ScopedDependency(TaskCompletionSource disposed) : IAsyncDisposable + { + public ValueTask DisposeAsync() + { + disposed.TrySetResult(true); + return default; + } + } + + [McpServerToolType] + private sealed class TaskFilterTools + { + [McpServerTool(Name = "task-filter-tool")] + public static string Invoke(ScopedDependency dependency) => "task filter result"; + + [McpServerTool(Name = "alternate-filter-exception-tool")] + public static string ThrowingAlternateFilterTarget() => "unreachable"; + + [McpServerTool(Name = "alternate-short-circuit-tool")] + public static string ShortCircuitedAlternateFilterTarget() => "unreachable"; + + [McpServerTool(Name = "replace-jsonrpc-request-tool")] + public static string ReplaceJsonRpcRequestTarget() => "replacement succeeded"; + + [McpServerTool(Name = "replace-request-context-tool")] + public static string ReplaceRequestContextTarget() => "context replacement succeeded"; + + [McpServerTool(Name = "alternate-transform-result-tool")] + public static string AlternateTransformResultTarget() => "original"; + + [McpServerTool(Name = "suppress-flow-direct-tool")] + public static string SuppressFlowDirect() => "direct succeeded"; + + [McpServerTool(Name = "suppress-flow-task-tool")] + public static string SuppressFlowTask() => "task succeeded"; + } +} diff --git a/tests/ModelContextProtocol.Tests/Server/TaskCancellationIntegrationTests.cs b/tests/ModelContextProtocol.Tests/Server/TaskCancellationIntegrationTests.cs index cc075a676..e751bdcdc 100644 --- a/tests/ModelContextProtocol.Tests/Server/TaskCancellationIntegrationTests.cs +++ b/tests/ModelContextProtocol.Tests/Server/TaskCancellationIntegrationTests.cs @@ -1,15 +1,19 @@ +using ModelContextProtocol.Extensions.Tasks; using Microsoft.Extensions.DependencyInjection; using ModelContextProtocol.Client; using ModelContextProtocol.Protocol; using ModelContextProtocol.Server; using ModelContextProtocol.Tests.Utils; +using System.Runtime.InteropServices; using System.Text.Json; +#pragma warning disable MCPEXP001 + namespace ModelContextProtocol.Tests.Server; /// -/// Integration tests for task cancellation behavior, including TTL-based automatic -/// cancellation and explicit cancellation via tasks/cancel. +/// Integration tests for task cancellation behavior, including explicit cancellation +/// via tasks/cancel and TTL-based automatic cancellation. /// public class TaskCancellationIntegrationTests : ClientServerTestBase { @@ -19,27 +23,25 @@ public class TaskCancellationIntegrationTests : ClientServerTestBase public TaskCancellationIntegrationTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) { +#if !NET + Assert.SkipWhen(RuntimeInformation.IsOSPlatform(OSPlatform.Windows), "https://github.com/modelcontextprotocol/csharp-sdk/issues/587"); +#endif } protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) { - // Add task store for server-side task support - var taskStore = new InMemoryMcpTaskStore(); - services.AddSingleton(taskStore); - - services.Configure(options => - { - options.TaskStore = taskStore; - }); - - // Add a long-running tool that captures cancellation - mcpServerBuilder.WithTools([McpServerTool.Create( + mcpServerBuilder + .WithTasks(new InMemoryMcpTaskStore + { + DefaultPollIntervalMs = 50, + DefaultTimeToLive = TimeSpan.FromSeconds(5), + }) + .WithTools([McpServerTool.Create( async (CancellationToken ct) => { _toolStarted.TrySetResult(true); try { - // Wait indefinitely until cancelled await Task.Delay(Timeout.Infinite, ct); return "completed"; } @@ -56,127 +58,54 @@ protected override void ConfigureServices(ServiceCollection services, IMcpServer })]); } - private static IDictionary EmptyArguments() => new Dictionary(); - - [Fact] - public async Task TaskTool_CancellationToken_FiresWhenTtlExpires() - { - // Arrange - await using McpClient client = await CreateMcpClientForServer(); - - // Act - Call tool with short TTL (200ms) - var callResult = await client.CallToolAsync( - new CallToolRequestParams - { - Name = "long-running-tool", - Arguments = EmptyArguments(), - // Use a TTL long enough that thread pool scheduling delays on loaded CI machines - // don't cause the CTS to fire before the tool lambda begins executing. - Task = new McpTaskMetadata { TimeToLive = TimeSpan.FromSeconds(5) } - }, - cancellationToken: TestContext.Current.CancellationToken); - - // Verify task was created - Assert.NotNull(callResult.Task); - - // Wait for the tool to start executing - await _toolStarted.Task.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); - - // Assert - Wait for the cancellation to fire (should happen when TTL expires) - var cancelled = await _toolCancellationFired.Task.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); - Assert.True(cancelled, "Tool's CancellationToken should have been triggered when TTL expired"); - - // Note: TTL-based expiration does not explicitly set task status to Cancelled. - // Instead, expired tasks are considered "dead" and will be cleaned up by the task store. - // The task may still be in Working status or may throw "not found" if already cleaned up. - } - [Fact] public async Task TaskTool_CancellationToken_FiresWhenExplicitlyCancelled() { - // Arrange - await using McpClient client = await CreateMcpClientForServer(); + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; - // Start a long-running task with a long TTL - var callResult = await client.CallToolAsync( - new CallToolRequestParams - { - Name = "long-running-tool", - Arguments = EmptyArguments(), - Task = new McpTaskMetadata { TimeToLive = TimeSpan.FromMinutes(10) } - }, - cancellationToken: TestContext.Current.CancellationToken); + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "long-running-tool" }, ct); - Assert.NotNull(callResult.Task); - string taskId = callResult.Task.TaskId; + Assert.True(augmented.IsTask); + var taskId = augmented.TaskCreated!.TaskId; // Wait for the tool to start executing - await _toolStarted.Task.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); + await _toolStarted.Task.WaitAsync(TestConstants.DefaultTimeout, ct); - // Act - Explicitly cancel the task - var cancelledTask = await client.CancelTaskAsync(taskId, cancellationToken: TestContext.Current.CancellationToken); + // Explicitly cancel the task + await client.CancelTaskAsync(taskId, ct); - // Assert - Wait for the cancellation to propagate to the tool - var cancelled = await _toolCancellationFired.Task.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); - Assert.True(cancelled, "Tool's CancellationToken should have been triggered by explicit cancellation"); + // Wait for the cancellation to propagate to the tool + var cancelled = await _toolCancellationFired.Task.WaitAsync(TestConstants.DefaultTimeout, ct); + Assert.True(cancelled); - // Verify task status - Assert.Equal(McpTaskStatus.Cancelled, cancelledTask.Status); + // Verify task status shows cancelled + var taskResult = await client.GetTaskAsync(taskId, ct); + Assert.IsType(taskResult); } [Fact] - public async Task TaskTool_CompletesSuccessfully_WhenNotCancelled() + public async Task TaskTool_CancellationToken_GetTaskShowsWorkingBeforeCancel() { - // Arrange - Create a new test with a quick-completing tool - var quickToolCompleted = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - - var services = new ServiceCollection(); - services.AddLogging(); - var taskStore = new InMemoryMcpTaskStore(); - services.AddSingleton(taskStore); - - var builder = services - .AddMcpServer() - .WithStreamServerTransport( - new System.IO.Pipelines.Pipe().Reader.AsStream(), - new System.IO.Pipelines.Pipe().Writer.AsStream()); - - builder.WithTools([McpServerTool.Create( - async (string input, CancellationToken ct) => - { - await Task.Delay(50, ct); // Quick operation - var result = $"Result: {input}"; - quickToolCompleted.TrySetResult(result); - return result; - }, - new McpServerToolCreateOptions - { - Name = "quick-tool", - Description = "A tool that completes quickly" - })]); + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; - services.Configure(options => - { - options.TaskStore = taskStore; - }); + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "long-running-tool" }, ct); - await using var client = await CreateMcpClientForServer(); + Assert.True(augmented.IsTask); + var taskId = augmented.TaskCreated!.TaskId; - // Act - Call tool with long TTL - var callResult = await client.CallToolAsync( - new CallToolRequestParams - { - Name = "long-running-tool", // Use the base class tool which will block - Arguments = EmptyArguments(), - Task = new McpTaskMetadata { TimeToLive = TimeSpan.FromMinutes(5) } - }, - cancellationToken: TestContext.Current.CancellationToken); + // Wait for the tool to start + await _toolStarted.Task.WaitAsync(TestConstants.DefaultTimeout, ct); - Assert.NotNull(callResult.Task); + // Check status while still running + var taskResult = await client.GetTaskAsync(taskId, ct); + Assert.IsType(taskResult); - // Verify task is in working state initially - var task = await client.GetTaskAsync(callResult.Task.TaskId, cancellationToken: TestContext.Current.CancellationToken); - Assert.Equal(McpTaskStatus.Working, task.Status); + // Cleanup + await client.CancelTaskAsync(taskId, ct); } } @@ -192,20 +121,19 @@ public class TaskCancellationConcurrencyTests : ClientServerTestBase public TaskCancellationConcurrencyTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) { +#if !NET + Assert.SkipWhen(RuntimeInformation.IsOSPlatform(OSPlatform.Windows), "https://github.com/modelcontextprotocol/csharp-sdk/issues/587"); +#endif } protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) { - var taskStore = new InMemoryMcpTaskStore(); - services.AddSingleton(taskStore); - - services.Configure(options => - { - options.TaskStore = taskStore; - }); - - // Tool that tracks cancellation per-invocation using a marker argument - mcpServerBuilder.WithTools([McpServerTool.Create( + mcpServerBuilder + .WithTasks(new InMemoryMcpTaskStore + { + DefaultPollIntervalMs = 50, + }) + .WithTools([McpServerTool.Create( async (string marker, CancellationToken ct) => { TaskCompletionSource startTcs; @@ -279,102 +207,47 @@ private static IDictionary CreateMarkerArgs(string marker) [Fact] public async Task CancelTask_OnlyCancelsTargetTask_NotOtherTasks() { - // Arrange - await using McpClient client = await CreateMcpClientForServer(); + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; RegisterMarker("task1"); RegisterMarker("task2"); // Start two tasks - var result1 = await client.CallToolAsync( + var result1 = await client.CallToolAsTaskAsync( new CallToolRequestParams { Name = "trackable-tool", Arguments = CreateMarkerArgs("task1"), - Task = new McpTaskMetadata { TimeToLive = TimeSpan.FromMinutes(10) } - }, - cancellationToken: TestContext.Current.CancellationToken); + }, ct); - var result2 = await client.CallToolAsync( + var result2 = await client.CallToolAsTaskAsync( new CallToolRequestParams { Name = "trackable-tool", Arguments = CreateMarkerArgs("task2"), - Task = new McpTaskMetadata { TimeToLive = TimeSpan.FromMinutes(10) } - }, - cancellationToken: TestContext.Current.CancellationToken); + }, ct); - Assert.NotNull(result1.Task); - Assert.NotNull(result2.Task); + Assert.True(result1.IsTask); + Assert.True(result2.IsTask); // Wait for both tools to start - await WaitForStart("task1", TestContext.Current.CancellationToken); - await WaitForStart("task2", TestContext.Current.CancellationToken); + await WaitForStart("task1", ct); + await WaitForStart("task2", ct); - // Act - Cancel only task1 - await client.CancelTaskAsync(result1.Task.TaskId, cancellationToken: TestContext.Current.CancellationToken); + // Cancel only task1 + await client.CancelTaskAsync(result1.TaskCreated!.TaskId, ct); - // Assert - task1 should be cancelled - var task1Cancelled = await WaitForCancellation("task1", TestContext.Current.CancellationToken); - Assert.True(task1Cancelled, "Task1 should have been cancelled"); + // task1 should be cancelled + var task1Cancelled = await WaitForCancellation("task1", ct); + Assert.True(task1Cancelled); - // task2 should still be running (give it a moment to verify it wasn't cancelled) - var task2Status = await client.GetTaskAsync(result2.Task.TaskId, cancellationToken: TestContext.Current.CancellationToken); - Assert.Equal(McpTaskStatus.Working, task2Status.Status); + // task2 should still be working + var task2Status = await client.GetTaskAsync(result2.TaskCreated!.TaskId, ct); + Assert.IsType(task2Status); - // Clean up - cancel task2 - await client.CancelTaskAsync(result2.Task.TaskId, cancellationToken: TestContext.Current.CancellationToken); - } - - [Fact] - public async Task MultipleTasks_WithDifferentTtls_CancelIndependently() - { - // Arrange - await using McpClient client = await CreateMcpClientForServer(); - - RegisterMarker("short-ttl"); - RegisterMarker("long-ttl"); - - // Start task with short TTL. Use a TTL long enough that thread pool scheduling - // delays on loaded CI machines don't cause the CTS to fire before the tool - // lambda begins executing (CancelAfter starts counting at task creation, not - // when the tool's Task.Run is scheduled). - var shortTtlResult = await client.CallToolAsync( - new CallToolRequestParams - { - Name = "trackable-tool", - Arguments = CreateMarkerArgs("short-ttl"), - Task = new McpTaskMetadata { TimeToLive = TimeSpan.FromSeconds(5) } - }, - cancellationToken: TestContext.Current.CancellationToken); - - // Start task with long TTL - var longTtlResult = await client.CallToolAsync( - new CallToolRequestParams - { - Name = "trackable-tool", - Arguments = CreateMarkerArgs("long-ttl"), - Task = new McpTaskMetadata { TimeToLive = TimeSpan.FromMinutes(10) } - }, - cancellationToken: TestContext.Current.CancellationToken); - - Assert.NotNull(shortTtlResult.Task); - Assert.NotNull(longTtlResult.Task); - - // Wait for both to start - await WaitForStart("short-ttl", TestContext.Current.CancellationToken); - await WaitForStart("long-ttl", TestContext.Current.CancellationToken); - - // Assert - short TTL task should be cancelled automatically - var shortCancelled = await WaitForCancellation("short-ttl", TestContext.Current.CancellationToken); - Assert.True(shortCancelled, "Short TTL task should have been cancelled when TTL expired"); - - // Long TTL task should still be running - var longTtlStatus = await client.GetTaskAsync(longTtlResult.Task.TaskId, cancellationToken: TestContext.Current.CancellationToken); - Assert.Equal(McpTaskStatus.Working, longTtlStatus.Status); - - // Clean up - await client.CancelTaskAsync(longTtlResult.Task.TaskId, cancellationToken: TestContext.Current.CancellationToken); + // Cleanup + await client.CancelTaskAsync(result2.TaskCreated!.TaskId, ct); } } @@ -388,19 +261,19 @@ public class TerminalTaskStatusTransitionTests : ClientServerTestBase public TerminalTaskStatusTransitionTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) { +#if !NET + Assert.SkipWhen(RuntimeInformation.IsOSPlatform(OSPlatform.Windows), "https://github.com/modelcontextprotocol/csharp-sdk/issues/587"); +#endif } protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) { - var taskStore = new InMemoryMcpTaskStore(); - services.AddSingleton(taskStore); - - services.Configure(options => - { - options.TaskStore = taskStore; - }); - - mcpServerBuilder.WithTools([ + mcpServerBuilder + .WithTasks(new InMemoryMcpTaskStore + { + DefaultPollIntervalMs = 50, + }) + .WithTools([ McpServerTool.Create( async (CancellationToken ct) => { @@ -429,81 +302,63 @@ protected override void ConfigureServices(ServiceCollection services, IMcpServer ]); } - private static IDictionary EmptyArguments() => new Dictionary(); - [Fact] - public async Task CompletedTask_CannotTransitionToOtherStatus() + public async Task CompletedTask_CancelIsAcknowledgedIdempotentlyAndStateUnchanged() { - // Arrange - await using McpClient client = await CreateMcpClientForServer(); + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; - var callResult = await client.CallToolAsync( - new CallToolRequestParams - { - Name = "quick-tool", - Arguments = EmptyArguments(), - Task = new McpTaskMetadata() - }, - cancellationToken: TestContext.Current.CancellationToken); + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "quick-tool" }, ct); - Assert.NotNull(callResult.Task); - string taskId = callResult.Task.TaskId; + Assert.True(augmented.IsTask); + var taskId = augmented.TaskCreated!.TaskId; // Wait for completion - McpTask taskStatus; + GetTaskResult? taskResult; do { - await Task.Delay(50, TestContext.Current.CancellationToken); - taskStatus = await client.GetTaskAsync(taskId, cancellationToken: TestContext.Current.CancellationToken); + await Task.Delay(50, ct); + taskResult = await client.GetTaskAsync(taskId, ct); } - while (taskStatus.Status == McpTaskStatus.Working); - - Assert.Equal(McpTaskStatus.Completed, taskStatus.Status); + while (taskResult is not CompletedTaskResult); - // Act - Try to cancel a completed task (should be idempotent) - var cancelResult = await client.CancelTaskAsync(taskId, cancellationToken: TestContext.Current.CancellationToken); + // SEP-2663: cancel on a terminal task must be acknowledged idempotently. + var cancelResult = await client.CancelTaskAsync(taskId, ct); + Assert.NotNull(cancelResult); - // Assert - Status should still be completed (not cancelled) - Assert.Equal(McpTaskStatus.Completed, cancelResult.Status); - - // Verify via get - var verifyStatus = await client.GetTaskAsync(taskId, cancellationToken: TestContext.Current.CancellationToken); - Assert.Equal(McpTaskStatus.Completed, verifyStatus.Status); + // Verify status is still completed (not flipped to cancelled). + var verifyResult = await client.GetTaskAsync(taskId, ct); + Assert.IsType(verifyResult); } [Fact] - public async Task FailedTask_CannotTransitionToOtherStatus() + public async Task CompletedWithErrorTask_CancelIsAcknowledgedIdempotently() { - // Arrange - await using McpClient client = await CreateMcpClientForServer(); + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; - var callResult = await client.CallToolAsync( - new CallToolRequestParams - { - Name = "failing-tool", - Arguments = EmptyArguments(), - Task = new McpTaskMetadata() - }, - cancellationToken: TestContext.Current.CancellationToken); + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "failing-tool" }, ct); - Assert.NotNull(callResult.Task); - string taskId = callResult.Task.TaskId; + Assert.True(augmented.IsTask); + var taskId = augmented.TaskCreated!.TaskId; - // Wait for failure - McpTask taskStatus; + // Wait for completion (tool errors are wrapped as completed with isError=true) + GetTaskResult? taskResult; do { - await Task.Delay(50, TestContext.Current.CancellationToken); - taskStatus = await client.GetTaskAsync(taskId, cancellationToken: TestContext.Current.CancellationToken); + await Task.Delay(50, ct); + taskResult = await client.GetTaskAsync(taskId, ct); } - while (taskStatus.Status == McpTaskStatus.Working); - - Assert.Equal(McpTaskStatus.Failed, taskStatus.Status); + while (taskResult is not CompletedTaskResult); - // Act - Try to cancel a failed task (should be idempotent) - var cancelResult = await client.CancelTaskAsync(taskId, cancellationToken: TestContext.Current.CancellationToken); + // SEP-2663: cancel on a terminal task must be acknowledged idempotently. + var cancelResult = await client.CancelTaskAsync(taskId, ct); + Assert.NotNull(cancelResult); - // Assert - Status should still be failed - Assert.Equal(McpTaskStatus.Failed, cancelResult.Status); + // Verify status is still completed (not flipped to cancelled). + var verifyResult = await client.GetTaskAsync(taskId, ct); + Assert.IsType(verifyResult); } } diff --git a/tests/ModelContextProtocol.Tests/Server/TaskHandlerConfigurationValidationTests.cs b/tests/ModelContextProtocol.Tests/Server/TaskHandlerConfigurationValidationTests.cs new file mode 100644 index 000000000..621acfddb --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/TaskHandlerConfigurationValidationTests.cs @@ -0,0 +1,64 @@ +using ModelContextProtocol.Extensions.Tasks; +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.Runtime.InteropServices; +using System.Text.Json; +using System.Text.Json.Serialization.Metadata; + +namespace ModelContextProtocol.Tests.Server; + +/// +/// Verifies behavior when a handler returns a alternate without +/// the server having any tasks/get handler registered. After the ResultOrAlternate +/// generalization, the Core server no longer guards against this -- the extension is responsible +/// for ensuring lifecycle handlers are registered. +/// +public class TaskHandlerConfigurationValidationTests : ClientServerTestBase +{ + private static readonly JsonTypeInfo s_createTaskResultTypeInfo = McpTasksJsonContext.Default.CreateTaskResult; + + public TaskHandlerConfigurationValidationTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) + { +#if !NET + Assert.SkipWhen(RuntimeInformation.IsOSPlatform(OSPlatform.Windows), "https://github.com/modelcontextprotocol/csharp-sdk/issues/587"); +#endif + } + +#pragma warning disable MCPEXP002 // exercises the experimental CallToolWithAlternateHandler/ResultOrAlternate seam + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + mcpServerBuilder.Services.Configure(options => + { + options.Capabilities ??= new ServerCapabilities(); + + // Configure a task-augmented handler without TaskStore or any of the + // task lifecycle request handlers. + options.Handlers.CallToolWithAlternateHandler = (context, cancellationToken) => + new ValueTask>( + ResultOrAlternate.FromAlternate( + new CreateTaskResult + { + TaskId = "orphan-task", + Status = McpTaskStatus.Working, + CreatedAt = DateTimeOffset.UtcNow, + LastUpdatedAt = DateTimeOffset.UtcNow, + }, + s_createTaskResultTypeInfo)); + }); + } +#pragma warning restore MCPEXP002 + + [Fact] + public async Task ServerAcceptsAlternateHandler_WithoutTasksGetHandler_NoStartupError() + { + // The Core guard that previously threw InvalidOperationException at request time when + // a CallToolWithAlternateHandler returned a CreateTaskResult without tasks/get being + // registered has been removed. The extension is now responsible for that guarantee. + // This test verifies the server starts and connects successfully with such configuration. + await using var client = await CreateMcpClientForServer(); + + // If we get here, the server accepted the handler config without error. + Assert.NotNull(client); + } +} diff --git a/tests/ModelContextProtocol.Tests/Server/TaskPollStuckDetectorTests.cs b/tests/ModelContextProtocol.Tests/Server/TaskPollStuckDetectorTests.cs new file mode 100644 index 000000000..c2552abd3 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/TaskPollStuckDetectorTests.cs @@ -0,0 +1,132 @@ +using ModelContextProtocol.Extensions.Tasks; +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.Runtime.InteropServices; +using System.Text.Json; +using System.Text.Json.Nodes; + +#pragma warning disable MCPEXP001, MCPEXP002 + +namespace ModelContextProtocol.Tests.Server; + +/// +/// Exercises the client-side guard that prevents an unbounded poll loop when a server keeps a +/// task in without publishing any new input requests +/// after every previously requested input has been resolved. +/// +public class TaskPollStuckDetectorTests : ClientServerTestBase +{ + private int _pollCount = 0; + + public TaskPollStuckDetectorTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) + { +#if !NET + Assert.SkipWhen(RuntimeInformation.IsOSPlatform(OSPlatform.Windows), "https://github.com/modelcontextprotocol/csharp-sdk/issues/587"); +#endif + } + + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + mcpServerBuilder.Services.Configure(options => + { + options.Capabilities ??= new ServerCapabilities(); + options.Capabilities.Extensions ??= new Dictionary(); + options.Capabilities.Extensions[TasksProtocol.ExtensionId] = new JsonObject(); + options.RequestHandlers ??= new List(); + + // CallTool always returns a CreateTaskResult with a tiny poll interval so the + // test exercises the threshold in well under a second. + options.Handlers.CallToolWithAlternateHandler = (context, cancellationToken) => + { + var taskId = Guid.NewGuid().ToString("N"); + return new ValueTask>( + ResultOrAlternate.FromAlternate( + new CreateTaskResult + { + TaskId = taskId, + Status = McpTaskStatus.InputRequired, + CreatedAt = DateTimeOffset.UtcNow, + LastUpdatedAt = DateTimeOffset.UtcNow, + PollIntervalMs = 5, + ResultType = "task", + }, + McpTasksJsonContext.Default.CreateTaskResult)); + }; + + // GetTask always reports InputRequired with NO outstanding input requests — the + // misbehaving-server condition the stuck-detector exists to break out of. + options.RequestHandlers.Add(new McpServerRequestHandler + { + Method = TasksProtocol.MethodTasksGet, + Handler = (request, cancellationToken) => + { + var requestParams = JsonSerializer.Deserialize(request.Params, McpTasksJsonContext.Default.Options) + ?? throw new McpProtocolException("Missing params for tasks/get", McpErrorCode.InvalidParams); + + Interlocked.Increment(ref _pollCount); + + return new ValueTask(JsonSerializer.SerializeToNode(new InputRequiredTaskResult + { + TaskId = requestParams.TaskId, + CreatedAt = DateTimeOffset.UtcNow, + LastUpdatedAt = DateTimeOffset.UtcNow, + PollIntervalMs = 5, + InputRequests = new Dictionary(), + ResultType = "complete", + }, McpTasksJsonContext.Default.Options)); + }, + }); + + options.RequestHandlers.Add(new McpServerRequestHandler + { + Method = TasksProtocol.MethodTasksCancel, + Handler = (request, cancellationToken) => + new ValueTask(JsonSerializer.SerializeToNode(new CancelTaskResult { ResultType = "complete" }, McpTasksJsonContext.Default.Options)), + }); + + options.RequestHandlers.Add(new McpServerRequestHandler + { + Method = TasksProtocol.MethodTasksUpdate, + Handler = (request, cancellationToken) => + new ValueTask(JsonSerializer.SerializeToNode(new UpdateTaskResult { ResultType = "complete" }, McpTasksJsonContext.Default.Options)), + }); + }); + } + + [Fact] + public async Task CallToolAsync_TaskStuckInInputRequired_WithoutNewRequests_ThrowsAfterThreshold() + { + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; + + var ex = await Assert.ThrowsAsync(async () => + await client.CallToolWithPollingAsync(new CallToolRequestParams { Name = "any-tool" }, cancellationToken: ct)); + + Assert.Contains(McpTaskStatus.InputRequired.ToString(), ex.Message); + Assert.Contains("consecutive polls", ex.Message); + + Assert.Equal(60, _pollCount); + } + + [Fact] + public async Task CallToolAsync_StuckDetector_HonorsConfiguredThreshold() + { + // Verifies CallToolWithPollingAsync plumbs the explicit threshold into PollTaskToCompletionAsync: + // a smaller configured threshold is surfaced verbatim in the McpException message. + const int CustomThreshold = 3; + + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; + + var ex = await Assert.ThrowsAsync(async () => + await client.CallToolWithPollingAsync(new CallToolRequestParams { Name = "any-tool" }, maxConsecutiveStuckPolls: CustomThreshold, cancellationToken: ct)); + + // The message embeds the configured threshold, which is the strongest signal that the + // option value (not the 60-default constant) is what governed the loop. + Assert.Contains($"{CustomThreshold} consecutive polls", ex.Message); + Assert.Equal(CustomThreshold, _pollCount); + } + +} diff --git a/tests/ModelContextProtocol.Tests/Server/TaskProtocolGatingTests.cs b/tests/ModelContextProtocol.Tests/Server/TaskProtocolGatingTests.cs new file mode 100644 index 000000000..6fa9fa215 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/TaskProtocolGatingTests.cs @@ -0,0 +1,183 @@ +using ModelContextProtocol.Extensions.Tasks; +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.Runtime.InteropServices; +using System.Text.Json; +using System.Text.Json.Nodes; + +namespace ModelContextProtocol.Tests.Server; + +/// +/// Verifies that the SEP-2663 Tasks extension is gated to the 2026-07-28 protocol revision on both the +/// client and the server. Explicit task operations throw on a legacy session; best-effort task +/// augmentation silently downgrades to a direct result so that legacy peers never see a task. +/// +public class TaskProtocolGatingTests : ClientServerTestBase +{ + private const string LatestStableVersion = "2025-11-25"; + + private const string ClientCapabilitiesMetaKey = "io.modelcontextprotocol/clientCapabilities"; + private const string ExtensionsKey = "extensions"; + + public TaskProtocolGatingTests(ITestOutputHelper outputHelper) + : base(outputHelper) + { +#if !NET + Assert.SkipWhen(RuntimeInformation.IsOSPlatform(OSPlatform.Windows), "https://github.com/modelcontextprotocol/csharp-sdk/issues/587"); +#endif + } + + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + mcpServerBuilder + .WithTasks(new InMemoryMcpTaskStore + { + DefaultPollIntervalMs = 50, + }) + .WithTools([McpServerTool.Create( + async (string input, CancellationToken ct) => + { + await Task.Delay(50, ct); + return $"Processed: {input}"; + }, + new McpServerToolCreateOptions + { + Name = "test-tool", + Description = "A test tool" + })]); + } + + private static IDictionary CreateArguments(string key, string value) + { + return new Dictionary + { + [key] = JsonDocument.Parse($"\"{value}\"").RootElement.Clone() + }; + } + + private static JsonObject CreateForgedTaskOptInMeta() => + new() + { + [ClientCapabilitiesMetaKey] = new JsonObject + { + [ExtensionsKey] = new JsonObject + { + [TasksProtocol.ExtensionId] = new JsonObject(), + }, + }, + }; + + [Fact] + public async Task LegacyClient_GetTaskAsync_ThrowsInvalidOperationException() + { + await using var client = await CreateMcpClientForServer(new McpClientOptions { ProtocolVersion = LatestStableVersion }); + var ct = TestContext.Current.CancellationToken; + + var ex = await Assert.ThrowsAsync(async () => + await client.GetTaskAsync("some-task-id", ct)); + + Assert.Contains("newer protocol revision that supports tasks", ex.Message); + } + + [Fact] + public async Task LegacyClient_UpdateTaskAsync_ThrowsInvalidOperationException() + { + await using var client = await CreateMcpClientForServer(new McpClientOptions { ProtocolVersion = LatestStableVersion }); + var ct = TestContext.Current.CancellationToken; + + var ex = await Assert.ThrowsAsync(async () => + await client.UpdateTaskAsync(new UpdateTaskRequestParams { TaskId = "some-task-id" }, ct)); + + Assert.Contains("newer protocol revision that supports tasks", ex.Message); + } + + [Fact] + public async Task LegacyClient_CancelTaskAsync_ThrowsInvalidOperationException() + { + await using var client = await CreateMcpClientForServer(new McpClientOptions { ProtocolVersion = LatestStableVersion }); + var ct = TestContext.Current.CancellationToken; + + var ex = await Assert.ThrowsAsync(async () => + await client.CancelTaskAsync("some-task-id", ct)); + + Assert.Contains("newer protocol revision that supports tasks", ex.Message); + } + + [Fact] + public async Task LegacyClient_CallToolRaw_ReturnsDirectResult_NoTaskCreated() + { + await using var client = await CreateMcpClientForServer(new McpClientOptions { ProtocolVersion = LatestStableVersion }); + var ct = TestContext.Current.CancellationToken; + + var result = await client.CallToolAsTaskAsync( + new CallToolRequestParams + { + Name = "test-tool", + Arguments = CreateArguments("input", "legacy"), + }, ct); + + Assert.False(result.IsTask); + Assert.NotNull(result.Result); + } + + [Fact] + public async Task LegacyClient_CallToolRaw_WithForgedTaskOptIn_RejectsReservedMetadata() + { + await using var client = await CreateMcpClientForServer(new McpClientOptions { ProtocolVersion = LatestStableVersion }); + var ct = TestContext.Current.CancellationToken; + + // Forge a SEP-2575 capabilities envelope carrying the tasks extension opt-in on a legacy + // request. The server rejects reserved per-request metadata before it can affect behavior. + var ex = await Assert.ThrowsAsync(async () => await client.CallToolAsTaskAsync( + new CallToolRequestParams + { + Name = "test-tool", + Arguments = CreateArguments("input", "forged"), + Meta = CreateForgedTaskOptInMeta(), + }, ct)); + + Assert.Equal(McpErrorCode.InvalidRequest, ex.ErrorCode); + Assert.Contains(ClientCapabilitiesMetaKey, ex.Message); + } + + [Fact] + public async Task LegacyClient_RawTasksGetRequest_ReturnsMethodNotFound() + { + await using var client = await CreateMcpClientForServer(new McpClientOptions { ProtocolVersion = LatestStableVersion }); + var ct = TestContext.Current.CancellationToken; + + // Bypass the typed GetTaskAsync client guard by sending a raw tasks/get request. The server + // gates tasks/* to the 2026-07-28 protocol and must reject this legacy request with MethodNotFound. + var request = new JsonRpcRequest + { + Method = TasksProtocol.MethodTasksGet, + Params = JsonSerializer.SerializeToNode( + new GetTaskRequestParams { TaskId = "some-task-id" }, McpTasksJsonContext.Default.Options), + }; + + var ex = await Assert.ThrowsAsync(async () => + await client.SendRequestAsync(request, ct)); + + Assert.Equal(McpErrorCode.MethodNotFound, ex.ErrorCode); + } + + [Fact] + public async Task July2026ProtocolClient_CallToolRaw_CreatesTask() + { + // Sanity: the default client negotiates the 2026-07-28 protocol, so the task flow still works. + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; + + var result = await client.CallToolAsTaskAsync( + new CallToolRequestParams + { + Name = "test-tool", + Arguments = CreateArguments("input", "july2026"), + }, ct); + + Assert.True(result.IsTask); + Assert.NotNull(result.TaskCreated); + } +} diff --git a/tests/ModelContextProtocol.Tests/Server/TaskStoreOrphanedTaskTests.cs b/tests/ModelContextProtocol.Tests/Server/TaskStoreOrphanedTaskTests.cs new file mode 100644 index 000000000..144b08476 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Server/TaskStoreOrphanedTaskTests.cs @@ -0,0 +1,90 @@ +using ModelContextProtocol.Extensions.Tasks; +using Microsoft.Extensions.DependencyInjection; +using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using System.Runtime.InteropServices; +using System.Text.Json; +using System.Text.Json.Serialization.Metadata; + +namespace ModelContextProtocol.Tests.Server; + +/// +/// Verifies that when both and +/// are configured and the handler returns +/// (IsTask = true), the store's pre-created task is failed with a +/// clear error rather than being orphaned in forever. +/// +public class TaskStoreOrphanedTaskTests : ClientServerTestBase +{ +#pragma warning disable MCPEXP002 // exercises the experimental CallToolWithAlternateHandler/ResultOrAlternate seam + private static readonly JsonTypeInfo s_createTaskResultTypeInfo = McpTasksJsonContext.Default.CreateTaskResult; + + public TaskStoreOrphanedTaskTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) + { +#if !NET + Assert.SkipWhen(RuntimeInformation.IsOSPlatform(OSPlatform.Windows), "https://github.com/modelcontextprotocol/csharp-sdk/issues/587"); +#endif + } + + protected override void ConfigureServices(ServiceCollection services, IMcpServerBuilder mcpServerBuilder) + { + mcpServerBuilder.WithTasks(new InMemoryMcpTaskStore()); + + mcpServerBuilder.Services.Configure(options => + { + options.Capabilities ??= new ServerCapabilities(); + + // Returning IsTask = true here while the tasks extension is also configured is the + // misconfiguration the server must guard against. + options.Handlers.CallToolWithAlternateHandler = (context, cancellationToken) => + new ValueTask>( + ResultOrAlternate.FromAlternate( + new CreateTaskResult + { + TaskId = "user-task", + Status = McpTaskStatus.Working, + CreatedAt = DateTimeOffset.UtcNow, + LastUpdatedAt = DateTimeOffset.UtcNow, + }, + s_createTaskResultTypeInfo)); + }); + } + + [Fact] + public async Task TaskStoreAndHandler_BothCreatingTasks_FailsStoreTaskWithClearError() + { + await using var client = await CreateMcpClientForServer(); + var ct = TestContext.Current.CancellationToken; + + // The store's task is created synchronously and its taskId returned to the client. + var augmented = await client.CallToolAsTaskAsync( + new CallToolRequestParams { Name = "anything" }, ct); + + Assert.True(augmented.IsTask); + var taskId = augmented.TaskCreated!.TaskId; + + // Poll until the background runner observes the handler's IsTask=true and fails the + // store's task. Without the fix this would loop forever in Working. + GetTaskResult? taskResult = null; + for (int i = 0; i < 40; i++) + { + await Task.Delay(50, ct); + taskResult = await client.GetTaskAsync(taskId, ct); + if (taskResult is FailedTaskResult) + { + break; + } + } + + var failed = Assert.IsType(taskResult); + Assert.Equal(JsonValueKind.Object, failed.Error.ValueKind); + Assert.Equal((int)McpErrorCode.InternalError, failed.Error.GetProperty("code").GetInt32()); + + var message = failed.Error.GetProperty("message").GetString(); + Assert.NotNull(message); + Assert.Contains(nameof(IMcpTaskStore), message); + Assert.Contains(nameof(McpServerHandlers.CallToolWithAlternateHandler), message); + } +#pragma warning restore MCPEXP002 +} diff --git a/tests/ModelContextProtocol.Tests/Server/ToolTaskSupportTests.cs b/tests/ModelContextProtocol.Tests/Server/ToolTaskSupportTests.cs deleted file mode 100644 index 25db2b330..000000000 --- a/tests/ModelContextProtocol.Tests/Server/ToolTaskSupportTests.cs +++ /dev/null @@ -1,727 +0,0 @@ -using Microsoft.Extensions.DependencyInjection; -using Microsoft.Extensions.Logging; -using ModelContextProtocol.Client; -using ModelContextProtocol.Protocol; -using ModelContextProtocol.Server; -using ModelContextProtocol.Tests.Utils; -using System.Text.Json; - -namespace ModelContextProtocol.Tests.Server; - -/// -/// Integration tests verifying that tools report correct ToolTaskSupport values -/// based on server configuration and method signatures. -/// -public class ToolTaskSupportTests : LoggedTest -{ - public ToolTaskSupportTests(ITestOutputHelper testOutputHelper) - : base(testOutputHelper) - { - } - - [Fact] - public async Task Tools_WithoutTaskStore_ReportForbiddenTaskSupport() - { - // Arrange - Server without a task store - await using var fixture = new ClientServerFixture( - LoggerFactory, - configureServer: builder => - { - builder.WithTools([ - McpServerTool.Create(async (string input, CancellationToken ct) => - { - await Task.Delay(10, ct); - return $"Async: {input}"; - }, - new McpServerToolCreateOptions { Name = "async-tool", Description = "An async tool" }), - - McpServerTool.Create((string input) => $"Sync: {input}", - new McpServerToolCreateOptions { Name = "sync-tool", Description = "A sync tool" }) - ]); - }); - - // Act - var tools = await fixture.Client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Both tools should have Forbidden task support when no task store is configured - Assert.Equal(2, tools.Count); - - var asyncTool = tools.Single(t => t.Name == "async-tool"); - var syncTool = tools.Single(t => t.Name == "sync-tool"); - - // Without a task store, async tools should still report Optional (their intrinsic capability) - // but the server won't have tasks in capabilities. The tool itself declares its support. - Assert.Equal(ToolTaskSupport.Optional, asyncTool.ProtocolTool.Execution?.TaskSupport); - - // Sync tools should have null Execution or Forbidden task support - Assert.True( - syncTool.ProtocolTool.Execution is null || - syncTool.ProtocolTool.Execution.TaskSupport is null || - syncTool.ProtocolTool.Execution.TaskSupport == ToolTaskSupport.Forbidden, - "Sync tools should not support task execution"); - } - - [Fact] - public async Task Tools_WithTaskStore_AsyncToolsReportOptionalTaskSupport() - { - // Arrange - Server with a task store - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ClientServerFixture( - LoggerFactory, - configureServer: builder => - { - builder.WithTools([ - McpServerTool.Create(async (string input, CancellationToken ct) => - { - await Task.Delay(10, ct); - return $"Async: {input}"; - }, - new McpServerToolCreateOptions { Name = "async-tool", Description = "An async tool" }), - - McpServerTool.Create((string input) => $"Sync: {input}", - new McpServerToolCreateOptions { Name = "sync-tool", Description = "A sync tool" }) - ]); - }, - configureServices: services => - { - services.AddSingleton(taskStore); - services.Configure(options => options.TaskStore = taskStore); - }); - - // Act - var tools = await fixture.Client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Assert.Equal(2, tools.Count); - - var asyncTool = tools.Single(t => t.Name == "async-tool"); - var syncTool = tools.Single(t => t.Name == "sync-tool"); - - // Async tools should report Optional task support - Assert.Equal(ToolTaskSupport.Optional, asyncTool.ProtocolTool.Execution?.TaskSupport); - - // Sync tools should have null Execution or Forbidden task support - Assert.True( - syncTool.ProtocolTool.Execution is null || - syncTool.ProtocolTool.Execution.TaskSupport is null || - syncTool.ProtocolTool.Execution.TaskSupport == ToolTaskSupport.Forbidden, - "Sync tools should not support task execution"); - } - - [Fact] - public async Task Tools_WithExplicitTaskSupport_ReportsConfiguredValue() - { - // Arrange - Server with explicit task support configured on tools - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ClientServerFixture( - LoggerFactory, - configureServer: builder => - { - builder.WithTools([ - McpServerTool.Create(async (string input, CancellationToken ct) => - { - await Task.Delay(10, ct); - return $"Async: {input}"; - }, - new McpServerToolCreateOptions - { - Name = "required-async-tool", - Description = "A tool that requires task execution", - Execution = new ToolExecution { TaskSupport = ToolTaskSupport.Required } - }), - - McpServerTool.Create((string input) => $"Sync: {input}", - new McpServerToolCreateOptions - { - Name = "forbidden-sync-tool", - Description = "A tool that forbids task execution", - Execution = new ToolExecution { TaskSupport = ToolTaskSupport.Forbidden } - }) - ]); - }, - configureServices: services => - { - services.AddSingleton(taskStore); - services.Configure(options => options.TaskStore = taskStore); - }); - - // Act - var tools = await fixture.Client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Assert.Equal(2, tools.Count); - - var requiredTool = tools.Single(t => t.Name == "required-async-tool"); - var forbiddenTool = tools.Single(t => t.Name == "forbidden-sync-tool"); - - Assert.Equal(ToolTaskSupport.Required, requiredTool.ProtocolTool.Execution?.TaskSupport); - Assert.Equal(ToolTaskSupport.Forbidden, forbiddenTool.ProtocolTool.Execution?.TaskSupport); - } - - [Fact] - public async Task ServerCapabilities_WithoutTaskStore_DoNotIncludeTasksCapability() - { - // Arrange - Server without a task store - await using var fixture = new ClientServerFixture( - LoggerFactory, - configureServer: builder => - { - builder.WithTools([ - McpServerTool.Create((string input) => $"Result: {input}", - new McpServerToolCreateOptions { Name = "test-tool" }) - ]); - }); - - // Assert - Server capabilities should not include tasks - Assert.Null(fixture.Client.ServerCapabilities?.Tasks); - } - - [Fact] - public async Task ServerCapabilities_WithTaskStore_IncludeTasksCapability() - { - // Arrange - Server with a task store - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ClientServerFixture( - LoggerFactory, - configureServer: builder => - { - builder.WithTools([ - McpServerTool.Create((string input) => $"Result: {input}", - new McpServerToolCreateOptions { Name = "test-tool" }) - ]); - }, - configureServices: services => - { - services.Configure(options => - { - options.TaskStore = taskStore; - }); - }); - - // Assert - Server capabilities should include tasks - Assert.NotNull(fixture.Client.ServerCapabilities?.Tasks); - Assert.NotNull(fixture.Client.ServerCapabilities.Tasks.List); - Assert.NotNull(fixture.Client.ServerCapabilities.Tasks.Cancel); - Assert.NotNull(fixture.Client.ServerCapabilities.Tasks.Requests?.Tools?.Call); - } - -#pragma warning disable MCPEXP001 // Tasks feature is experimental - [Fact] - public void McpServerToolAttribute_TaskSupport_CanBeSetOnAttribute() - { - // Test that the TaskSupport property can be set via the attribute - // and is correctly read when creating a tool - var tool = McpServerTool.Create(typeof(TaskSupportAttributeTestTools).GetMethod(nameof(TaskSupportAttributeTestTools.RequiredTaskTool))!); - Assert.NotNull(tool.ProtocolTool.Execution); - Assert.Equal(ToolTaskSupport.Required, tool.ProtocolTool.Execution.TaskSupport); - - var optionalTool = McpServerTool.Create(typeof(TaskSupportAttributeTestTools).GetMethod(nameof(TaskSupportAttributeTestTools.OptionalTaskTool))!); - Assert.NotNull(optionalTool.ProtocolTool.Execution); - Assert.Equal(ToolTaskSupport.Optional, optionalTool.ProtocolTool.Execution.TaskSupport); - - var forbiddenTool = McpServerTool.Create(typeof(TaskSupportAttributeTestTools).GetMethod(nameof(TaskSupportAttributeTestTools.ForbiddenTaskTool))!); - Assert.NotNull(forbiddenTool.ProtocolTool.Execution); - Assert.Equal(ToolTaskSupport.Forbidden, forbiddenTool.ProtocolTool.Execution.TaskSupport); - } - - [Fact] - public void McpServerToolAttribute_TaskSupport_WhenNotSet_AllowsAutoDetection() - { - // When TaskSupport is not set on the attribute, async tools should use auto-detection (Optional) - var asyncTool = McpServerTool.Create(typeof(TaskSupportAttributeTestTools).GetMethod(nameof(TaskSupportAttributeTestTools.AsyncToolWithoutTaskSupport))!); - Assert.NotNull(asyncTool.ProtocolTool.Execution); - Assert.Equal(ToolTaskSupport.Optional, asyncTool.ProtocolTool.Execution.TaskSupport); - - // Sync tools without TaskSupport set should have null Execution or Forbidden - var syncTool = McpServerTool.Create(typeof(TaskSupportAttributeTestTools).GetMethod(nameof(TaskSupportAttributeTestTools.SyncToolWithoutTaskSupport))!); - Assert.True( - syncTool.ProtocolTool.Execution is null || - syncTool.ProtocolTool.Execution.TaskSupport is null || - syncTool.ProtocolTool.Execution.TaskSupport == ToolTaskSupport.Forbidden, - "Sync tools without explicit TaskSupport should not support tasks"); - } - - [Fact] - public void McpServerToolAttribute_TaskSupport_ExplicitForbidden_OverridesAutoDetection() - { - // Verify that explicitly setting Forbidden overrides auto-detection for async methods - var forbiddenAsyncTool = McpServerTool.Create(typeof(TaskSupportAttributeTestTools).GetMethod(nameof(TaskSupportAttributeTestTools.ForbiddenAsyncTool))!); - Assert.NotNull(forbiddenAsyncTool.ProtocolTool.Execution); - Assert.Equal(ToolTaskSupport.Forbidden, forbiddenAsyncTool.ProtocolTool.Execution.TaskSupport); - } - - [Fact] - public void McpServerToolAttribute_TaskSupport_OptionalOnSyncMethod_IsAllowed() - { - // Setting Optional on a sync method is allowed - the tool will just execute very quickly - // This tests that the SDK doesn't prevent this configuration at tool creation time - var tool = McpServerTool.Create(typeof(TaskSupportAttributeTestTools).GetMethod(nameof(TaskSupportAttributeTestTools.OptionalTaskTool))!); - Assert.NotNull(tool.ProtocolTool.Execution); - Assert.Equal(ToolTaskSupport.Optional, tool.ProtocolTool.Execution.TaskSupport); - } - - [Fact] - public void McpServerToolAttribute_TaskSupport_RequiredOnSyncMethod_IsAllowed() - { - // Setting Required on a sync method is allowed - the tool will just execute very quickly - // This tests that the SDK doesn't prevent this configuration at tool creation time - var tool = McpServerTool.Create(typeof(TaskSupportAttributeTestTools).GetMethod(nameof(TaskSupportAttributeTestTools.RequiredTaskTool))!); - Assert.NotNull(tool.ProtocolTool.Execution); - Assert.Equal(ToolTaskSupport.Required, tool.ProtocolTool.Execution.TaskSupport); - } -#pragma warning restore MCPEXP001 - -#pragma warning disable MCPEXP001 // Tasks feature is experimental - [Fact] - public void McpServerToolAttribute_TaskSupport_WhenNotSet_DefaultsBasedOnMethodSignature() - { - // When TaskSupport is not set on the attribute, async tools should default to Optional - var asyncTool = McpServerTool.Create(typeof(TaskSupportAttributeTestTools).GetMethod(nameof(TaskSupportAttributeTestTools.AsyncToolWithoutTaskSupport))!); - Assert.NotNull(asyncTool.ProtocolTool.Execution); - Assert.Equal(ToolTaskSupport.Optional, asyncTool.ProtocolTool.Execution.TaskSupport); - - // Sync tools should have null or no Execution set - var syncTool = McpServerTool.Create(typeof(TaskSupportAttributeTestTools).GetMethod(nameof(TaskSupportAttributeTestTools.SyncToolWithoutTaskSupport))!); - Assert.True( - syncTool.ProtocolTool.Execution is null || - syncTool.ProtocolTool.Execution.TaskSupport is null || - syncTool.ProtocolTool.Execution.TaskSupport == ToolTaskSupport.Forbidden, - "Sync tools without explicit TaskSupport should not support tasks"); - } - - [Theory] - [InlineData(ToolTaskSupport.Forbidden, "\"forbidden\"")] - [InlineData(ToolTaskSupport.Optional, "\"optional\"")] - [InlineData(ToolTaskSupport.Required, "\"required\"")] - public void ToolTaskSupport_SerializesToJsonCorrectly(ToolTaskSupport value, string expectedJson) - { - var json = JsonSerializer.Serialize(value, McpJsonUtilities.DefaultOptions); - Assert.Equal(expectedJson, json); - } - - [Theory] - [InlineData("\"forbidden\"", ToolTaskSupport.Forbidden)] - [InlineData("\"optional\"", ToolTaskSupport.Optional)] - [InlineData("\"required\"", ToolTaskSupport.Required)] - public void ToolTaskSupport_DeserializesFromJsonCorrectly(string json, ToolTaskSupport expected) - { - var value = JsonSerializer.Deserialize(json, McpJsonUtilities.DefaultOptions); - Assert.Equal(expected, value); - } - - [Fact] - public void ToolExecution_TaskSupport_NullByDefault() - { - // Verify that ToolExecution.TaskSupport is null by default - var execution = new ToolExecution(); - Assert.Null(execution.TaskSupport); - - // When serialized with a value, it should appear correctly - var tool = new Tool - { - Name = "test", - Execution = new ToolExecution { TaskSupport = ToolTaskSupport.Optional } - }; - var toolJson = JsonSerializer.Serialize(tool, McpJsonUtilities.DefaultOptions); - Assert.Contains("\"optional\"", toolJson); - } - - [Fact] - public void McpServerToolCreateOptions_Execution_OverridesAutoDetection() - { - // When Execution is set via options, it should override auto-detection - var tool = McpServerTool.Create( - async (string input, CancellationToken ct) => - { - await Task.Delay(1, ct); - return input; - }, - new McpServerToolCreateOptions - { - Name = "test", - Execution = new ToolExecution { TaskSupport = ToolTaskSupport.Forbidden } - }); - - // Even though this is an async method, it should have Forbidden since it was explicitly set - Assert.NotNull(tool.ProtocolTool.Execution); - Assert.Equal(ToolTaskSupport.Forbidden, tool.ProtocolTool.Execution.TaskSupport); - } - - [Fact] - public void McpServerToolCreateOptions_Execution_Required_SetsCorrectly() - { - var tool = McpServerTool.Create( - (string input) => input, - new McpServerToolCreateOptions - { - Name = "test", - Execution = new ToolExecution { TaskSupport = ToolTaskSupport.Required } - }); - - Assert.NotNull(tool.ProtocolTool.Execution); - Assert.Equal(ToolTaskSupport.Required, tool.ProtocolTool.Execution.TaskSupport); - } - - [Fact] - public void ToolTaskSupport_EnumValues_AreCorrect() - { - // Verify enum values are as expected (Forbidden = 0) - Assert.Equal(0, (int)ToolTaskSupport.Forbidden); - Assert.Equal(1, (int)ToolTaskSupport.Optional); - Assert.Equal(2, (int)ToolTaskSupport.Required); - } - - [Fact] - public void McpServerToolAttribute_TaskSupport_PublicPropertyDefaultsToForbidden() - { - // Verify that the public property returns Forbidden when not set - var attr = new McpServerToolAttribute(); - Assert.Equal(ToolTaskSupport.Forbidden, attr.TaskSupport); - } -#pragma warning restore MCPEXP001 - - [McpServerToolType] - private static class TaskSupportAttributeTestTools - { -#pragma warning disable MCPEXP001 // Tasks feature is experimental - [McpServerTool(TaskSupport = ToolTaskSupport.Required)] - public static string RequiredTaskTool(string input) => $"Required: {input}"; - - [McpServerTool(TaskSupport = ToolTaskSupport.Optional)] - public static string OptionalTaskTool(string input) => $"Optional: {input}"; - - [McpServerTool(TaskSupport = ToolTaskSupport.Forbidden)] - public static string ForbiddenTaskTool(string input) => $"Forbidden: {input}"; - - [McpServerTool(TaskSupport = ToolTaskSupport.Forbidden)] - public static async Task ForbiddenAsyncTool(string input, CancellationToken ct) - { - await Task.Delay(1, ct); - return $"ForbiddenAsync: {input}"; - } -#pragma warning restore MCPEXP001 - - [McpServerTool] - public static async Task AsyncToolWithoutTaskSupport(string input, CancellationToken ct) - { - await Task.Delay(1, ct); - return $"Async: {input}"; - } - - [McpServerTool] - public static string SyncToolWithoutTaskSupport(string input) => $"Sync: {input}"; - } - - #region Sync Method with Optional/Required TaskSupport Integration Tests - -#pragma warning disable MCPEXP001 // Tasks feature is experimental - [Fact] - public async Task SyncTool_WithOptionalTaskSupport_CanBeCalledAsTask() - { - // Arrange - Server with task store and a sync tool with Optional task support - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ClientServerFixture( - LoggerFactory, - configureServer: builder => - { - builder.WithTools([McpServerTool.Create( - (string input) => $"Sync result: {input}", - new McpServerToolCreateOptions - { - Name = "optional-sync-tool", - Description = "A sync tool with optional task support", - Execution = new ToolExecution { TaskSupport = ToolTaskSupport.Optional } - })]); - }, - configureServices: services => - { - services.AddSingleton(taskStore); - services.Configure(options => options.TaskStore = taskStore); - }); - - // Act - Call the sync tool as a task - var mcpTask = await fixture.Client.CallToolAsTaskAsync( - "optional-sync-tool", - arguments: new Dictionary { ["input"] = "test" }, - taskMetadata: new McpTaskMetadata(), - progress: null, - cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Task was created successfully - Assert.NotNull(mcpTask); - Assert.NotEmpty(mcpTask.TaskId); - } - - [Fact] - public async Task SyncTool_WithRequiredTaskSupport_CanBeCalledAsTask() - { - // Arrange - Server with task store and a sync tool with Required task support - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ClientServerFixture( - LoggerFactory, - configureServer: builder => - { - builder.WithTools([McpServerTool.Create( - (string input) => $"Sync result: {input}", - new McpServerToolCreateOptions - { - Name = "required-sync-tool", - Description = "A sync tool with required task support", - Execution = new ToolExecution { TaskSupport = ToolTaskSupport.Required } - })]); - }, - configureServices: services => - { - services.AddSingleton(taskStore); - services.Configure(options => options.TaskStore = taskStore); - }); - - // Act - Call the sync tool as a task - var mcpTask = await fixture.Client.CallToolAsTaskAsync( - "required-sync-tool", - arguments: new Dictionary { ["input"] = "test" }, - taskMetadata: new McpTaskMetadata(), - progress: null, - cancellationToken: TestContext.Current.CancellationToken); - - // Assert - Task was created successfully - Assert.NotNull(mcpTask); - Assert.NotEmpty(mcpTask.TaskId); - } - - [Fact] - public async Task SyncTool_WithRequiredTaskSupport_CannotBeCalledDirectly() - { - // Arrange - Server with task store and a sync tool with Required task support - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ClientServerFixture( - LoggerFactory, - configureServer: builder => - { - builder.WithTools([McpServerTool.Create( - (string input) => $"Sync result: {input}", - new McpServerToolCreateOptions - { - Name = "required-sync-tool", - Description = "A sync tool with required task support", - Execution = new ToolExecution { TaskSupport = ToolTaskSupport.Required } - })]); - }, - configureServices: services => - { - services.AddSingleton(taskStore); - services.Configure(options => options.TaskStore = taskStore); - }); - - // Act & Assert - Calling directly should fail because task execution is required - var exception = await Assert.ThrowsAsync(() => - fixture.Client.CallToolAsync( - "required-sync-tool", - arguments: new Dictionary { ["input"] = "test" }, - cancellationToken: TestContext.Current.CancellationToken).AsTask()); - - // The server returns InvalidParams because direct invocation is not allowed for required-task tools - Assert.Equal(McpErrorCode.InvalidParams, exception.ErrorCode); - Assert.Contains("task", exception.Message, StringComparison.OrdinalIgnoreCase); - } - - [Fact] - public async Task TaskPath_Logs_Tool_Name_On_Successful_Call() - { - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ClientServerFixture( - LoggerFactory, - configureServer: builder => - { - builder.WithTools([McpServerTool.Create( - (string input) => $"Result: {input}", - new McpServerToolCreateOptions - { - Name = "task-success-tool", - Execution = new ToolExecution { TaskSupport = ToolTaskSupport.Optional } - })]); - }, - configureServices: services => - { - services.AddSingleton(MockLoggerProvider); - services.AddSingleton(taskStore); - services.Configure(options => options.TaskStore = taskStore); - }); - - var mcpTask = await fixture.Client.CallToolAsTaskAsync( - "task-success-tool", - arguments: new Dictionary { ["input"] = "test" }, - taskMetadata: new McpTaskMetadata(), - progress: null, - cancellationToken: TestContext.Current.CancellationToken); - - Assert.NotNull(mcpTask); - - // Wait for the async task execution to complete - await fixture.Client.GetTaskResultAsync(mcpTask.TaskId, cancellationToken: TestContext.Current.CancellationToken); - - var infoLog = Assert.Single(MockLoggerProvider.LogMessages, m => m.Message == "\"task-success-tool\" completed. IsError = False."); - Assert.Equal(LogLevel.Information, infoLog.LogLevel); - } - - [Fact] - public async Task TaskPath_Logs_Tool_Name_With_IsError_When_Tool_Returns_Error() - { - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ClientServerFixture( - LoggerFactory, - configureServer: builder => - { - builder.WithTools([McpServerTool.Create( - () => new CallToolResult - { - IsError = true, - Content = [new TextContentBlock { Text = "Task tool error" }], - }, - new McpServerToolCreateOptions - { - Name = "task-error-result-tool", - Execution = new ToolExecution { TaskSupport = ToolTaskSupport.Optional } - })]); - }, - configureServices: services => - { - services.AddSingleton(MockLoggerProvider); - services.AddSingleton(taskStore); - services.Configure(options => options.TaskStore = taskStore); - }); - - var mcpTask = await fixture.Client.CallToolAsTaskAsync( - "task-error-result-tool", - taskMetadata: new McpTaskMetadata(), - progress: null, - cancellationToken: TestContext.Current.CancellationToken); - - Assert.NotNull(mcpTask); - - // Wait for the async task execution to complete - await fixture.Client.GetTaskResultAsync(mcpTask.TaskId, cancellationToken: TestContext.Current.CancellationToken); - - var infoLog = Assert.Single(MockLoggerProvider.LogMessages, m => m.Message == "\"task-error-result-tool\" completed. IsError = True."); - Assert.Equal(LogLevel.Information, infoLog.LogLevel); - } - - [Fact] - public async Task TaskPath_Logs_Error_When_Tool_Throws() - { - var taskStore = new InMemoryMcpTaskStore(); - - await using var fixture = new ClientServerFixture( - LoggerFactory, - configureServer: builder => - { - builder.WithTools([McpServerTool.Create( - string () => throw new InvalidOperationException("Task tool error"), - new McpServerToolCreateOptions - { - Name = "task-throw-tool", - Execution = new ToolExecution { TaskSupport = ToolTaskSupport.Optional } - })]); - }, - configureServices: services => - { - services.AddSingleton(MockLoggerProvider); - services.AddSingleton(taskStore); - services.Configure(options => options.TaskStore = taskStore); - }); - - var mcpTask = await fixture.Client.CallToolAsTaskAsync( - "task-throw-tool", - taskMetadata: new McpTaskMetadata(), - progress: null, - cancellationToken: TestContext.Current.CancellationToken); - - Assert.NotNull(mcpTask); - - // Wait for the async task execution to complete - await fixture.Client.GetTaskResultAsync(mcpTask.TaskId, cancellationToken: TestContext.Current.CancellationToken); - - var errorLog = Assert.Single(MockLoggerProvider.LogMessages, m => m.LogLevel == LogLevel.Error); - Assert.Equal("\"task-throw-tool\" threw an unhandled exception.", errorLog.Message); - Assert.IsType(errorLog.Exception); - } -#pragma warning restore MCPEXP001 - - #endregion - - /// - /// A fixture that creates a connected MCP client-server pair for testing. - /// - private sealed class ClientServerFixture : IAsyncDisposable - { - private readonly System.IO.Pipelines.Pipe _clientToServerPipe = new(); - private readonly System.IO.Pipelines.Pipe _serverToClientPipe = new(); - private readonly CancellationTokenSource _cts; - private readonly Task _serverTask; - private readonly IServiceProvider _serviceProvider; - - public McpClient Client { get; } - public McpServer Server { get; } - - public ClientServerFixture( - ILoggerFactory loggerFactory, - Action? configureServer, - Action? configureServices = null) - { - ServiceCollection sc = new(); - sc.AddLogging(); - - var builder = sc - .AddMcpServer() - .WithStreamServerTransport(_clientToServerPipe.Reader.AsStream(), _serverToClientPipe.Writer.AsStream()); - - configureServer?.Invoke(builder); - configureServices?.Invoke(sc); - - _serviceProvider = sc.BuildServiceProvider(validateScopes: true); - _cts = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken); - - Server = _serviceProvider.GetRequiredService(); - _serverTask = Server.RunAsync(_cts.Token); - - // Create client synchronously by blocking - this is test code - Client = McpClient.CreateAsync( - new StreamClientTransport( - serverInput: _clientToServerPipe.Writer.AsStream(), - _serverToClientPipe.Reader.AsStream(), - loggerFactory), - loggerFactory: loggerFactory, - cancellationToken: TestContext.Current.CancellationToken).GetAwaiter().GetResult(); - } - - public async ValueTask DisposeAsync() - { - await Client.DisposeAsync(); - await _cts.CancelAsync(); - - _clientToServerPipe.Writer.Complete(); - _serverToClientPipe.Writer.Complete(); - - await _serverTask; - - if (_serviceProvider is IAsyncDisposable asyncDisposable) - { - await asyncDisposable.DisposeAsync(); - } - else if (_serviceProvider is IDisposable disposable) - { - disposable.Dispose(); - } - - _cts.Dispose(); - } - } -} diff --git a/tests/ModelContextProtocol.Tests/Transport/HttpClientTransportAutoDetectTests.cs b/tests/ModelContextProtocol.Tests/Transport/HttpClientTransportAutoDetectTests.cs index 768ebf7ea..7100e728a 100644 --- a/tests/ModelContextProtocol.Tests/Transport/HttpClientTransportAutoDetectTests.cs +++ b/tests/ModelContextProtocol.Tests/Transport/HttpClientTransportAutoDetectTests.cs @@ -1,5 +1,8 @@ using ModelContextProtocol.Client; +using ModelContextProtocol.Protocol; using ModelContextProtocol.Tests.Utils; +using Microsoft.Extensions.Logging; +using System.IO.Pipelines; using System.Net; namespace ModelContextProtocol.Tests.Transport; @@ -42,12 +45,70 @@ public async Task AutoDetectMode_UsesStreamableHttp_WhenServerSupportsIt() }; await using var session = await transport.ConnectAsync(TestContext.Current.CancellationToken); - + // The auto-detecting transport should be returned Assert.NotNull(session); } - [Fact] + [Fact] + public async Task AutoDetectMode_WhenBothTransportsFail_PreservesStreamableHttpException() + { + // Regression test: when Streamable HTTP POST fails (e.g. 403) and the SSE GET + // fallback also fails (e.g. 405), the original Streamable HTTP error should + // be preserved. The SSE connection failure is available as its inner exception. + var options = new HttpClientTransportOptions + { + Endpoint = new Uri("http://localhost"), + TransportMode = HttpTransportMode.AutoDetect, + Name = "AutoDetect test client" + }; + + using var mockHttpHandler = new MockHttpHandler(); + using var httpClient = new HttpClient(mockHttpHandler); + await using var transport = new HttpClientTransport(options, httpClient, LoggerFactory); + + mockHttpHandler.RequestHandler = (request) => + { + if (request.Method == HttpMethod.Post) + { + // Streamable HTTP POST fails with 403 (auth error) + return Task.FromResult(new HttpResponseMessage + { + StatusCode = HttpStatusCode.Forbidden, + Content = new StringContent("Forbidden") + }); + } + + if (request.Method == HttpMethod.Get) + { + // SSE GET fallback fails with 405 + return Task.FromResult(new HttpResponseMessage + { + StatusCode = HttpStatusCode.MethodNotAllowed, + Content = new StringContent("Method Not Allowed") + }); + } + + throw new InvalidOperationException($"Unexpected request: {request.Method}"); + }; + + // ConnectAsync for AutoDetect mode just creates the transport without sending + // any HTTP request. The auto-detection is triggered lazily by the first + // SendMessageAsync call, which happens inside McpClient.CreateAsync when it + // sends the JSON-RPC "initialize" message. + var ex = await Assert.ThrowsAsync( + () => McpClient.CreateAsync(transport, cancellationToken: TestContext.Current.CancellationToken)); + + Assert.Contains("403", ex.Message); + Assert.IsType(ex.InnerException); + Assert.Contains("405", ex.InnerException.Message); + Assert.Equal(HttpStatusCode.Forbidden, ex.Data["ModelContextProtocol.HttpStatusCode"]); +#if NET + Assert.Equal(HttpStatusCode.Forbidden, ex.StatusCode); +#endif + } + + [Fact] public async Task AutoDetectMode_FallsBackToSse_WhenStreamableHttpFails() { var options = new HttpClientTransportOptions @@ -102,8 +163,346 @@ public async Task AutoDetectMode_FallsBackToSse_WhenStreamableHttpFails() }; await using var session = await transport.ConnectAsync(TestContext.Current.CancellationToken); - + // The auto-detecting transport should be returned Assert.NotNull(session); } -} \ No newline at end of file + + [Fact] + public async Task AutoDetectMode_WhenProvisionalSseFails_LeavesSharedMessageChannelOpen() + { + var options = new HttpClientTransportOptions + { + Endpoint = new Uri("http://localhost"), + TransportMode = HttpTransportMode.AutoDetect, + Name = "AutoDetect shared channel test client" + }; + + using var mockHttpHandler = new MockHttpHandler(); + using var httpClient = new HttpClient(mockHttpHandler); + await using var transport = new HttpClientTransport(options, httpClient, LoggerFactory); + var streamableHttpPostCount = 0; + + mockHttpHandler.RequestHandler = request => + { + if (request.Method == HttpMethod.Get) + { + return Task.FromResult(new HttpResponseMessage(HttpStatusCode.MethodNotAllowed)); + } + + if (request.Method == HttpMethod.Post && ++streamableHttpPostCount == 1) + { + return Task.FromResult(new HttpResponseMessage(HttpStatusCode.NotFound) + { + Content = new StringContent("Invalid session ID"), + }); + } + + return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new StringContent( + "{\"jsonrpc\":\"2.0\",\"id\":2,\"result\":{\"protocolVersion\":\"2025-11-25\",\"capabilities\":{},\"serverInfo\":{\"name\":\"test\",\"version\":\"1.0\"}}}", + System.Text.Encoding.UTF8, + "application/json"), + }); + }; + + await using var session = await transport.ConnectAsync(TestContext.Current.CancellationToken); + + await Assert.ThrowsAsync(() => + session.SendMessageAsync( + new JsonRpcRequest { Method = RequestMethods.ServerDiscover, Id = new RequestId(1) }, + TestContext.Current.CancellationToken)); + + await session.SendMessageAsync( + new JsonRpcRequest { Method = RequestMethods.Initialize, Id = new RequestId(2) }, + TestContext.Current.CancellationToken); + + var response = await session.MessageReader.ReadAsync(TestContext.Current.CancellationToken); + Assert.Equal(new RequestId(2), Assert.IsType(response).Id); + } + + [Fact] + public async Task AutoDetectMode_WhenAdoptedSseDisconnects_CompletesSharedMessageChannel() + { + var options = new HttpClientTransportOptions + { + Endpoint = new Uri("http://localhost"), + TransportMode = HttpTransportMode.AutoDetect, + Name = "AutoDetect adopted SSE test client" + }; + + using var mockHttpHandler = new MockHttpHandler(); + using var httpClient = new HttpClient(mockHttpHandler); + await using var transport = new HttpClientTransport(options, httpClient, LoggerFactory); + var ssePipe = new Pipe(); + var postCount = 0; + + await ssePipe.Writer.WriteAsync( + System.Text.Encoding.UTF8.GetBytes("event: endpoint\r\ndata: /sse-endpoint\r\n\r\n"), + TestContext.Current.CancellationToken); + + mockHttpHandler.RequestHandler = request => + { + if (request.Method == HttpMethod.Get) + { + var content = new StreamContent(ssePipe.Reader.AsStream()); + content.Headers.ContentType = new("text/event-stream"); + return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK) { Content = content }); + } + + if (request.Method == HttpMethod.Post && ++postCount == 1) + { + return Task.FromResult(new HttpResponseMessage(HttpStatusCode.NotFound) + { + Content = new StringContent("Streamable HTTP not supported"), + }); + } + + return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)); + }; + + await using var session = await transport.ConnectAsync(TestContext.Current.CancellationToken); + + await session.SendMessageAsync( + new JsonRpcRequest { Method = RequestMethods.Initialize, Id = new RequestId(1) }, + TestContext.Current.CancellationToken); + + await ssePipe.Writer.CompleteAsync(); + + var exception = await Assert.ThrowsAsync( + async () => await session.MessageReader.Completion.WaitAsync( + TestConstants.DefaultTimeout, + TestContext.Current.CancellationToken)); + Assert.IsType(exception.Details); + } + + // Regression test for https://github.com/modelcontextprotocol/csharp-sdk/issues/1526 + // When Streamable HTTP returns 415 (e.g. wrong Content-Type) and the SSE fallback also fails + // (e.g. a Streamable-HTTP-only server returns 405 to the GET), the surfaced exception must + // preserve the original Streamable HTTP error rather than dropping it on the floor. + [Fact] + public async Task AutoDetectMode_PreservesOriginalError_WhenStreamableHttpReturns415AndSseFallbackFails() + { + var options = new HttpClientTransportOptions + { + Endpoint = new Uri("http://localhost"), + TransportMode = HttpTransportMode.AutoDetect, + Name = "AutoDetect test client" + }; + + using var mockHttpHandler = new MockHttpHandler(); + using var httpClient = new HttpClient(mockHttpHandler); + await using var transport = new HttpClientTransport(options, httpClient, LoggerFactory); + + const string streamableHttpBody = "Content-Type must be 'application/json'"; + + mockHttpHandler.RequestHandler = (request) => + { + if (request.Method == HttpMethod.Post) + { + // Streamable HTTP fails with 415 - this is the real server diagnostic the user needs to see. + return Task.FromResult(new HttpResponseMessage + { + StatusCode = HttpStatusCode.UnsupportedMediaType, + Content = new StringContent(streamableHttpBody), + }); + } + + if (request.Method == HttpMethod.Get) + { + // Streamable-HTTP-only server: SSE GET is rejected with 405. Without the fix this is the + // ONLY error the user ever sees, masking the real 415 diagnostic above. + return Task.FromResult(new HttpResponseMessage + { + StatusCode = HttpStatusCode.MethodNotAllowed, + Content = new StringContent("Method not allowed"), + }); + } + + throw new InvalidOperationException($"Unexpected request: {request.Method}"); + }; + + // ConnectAsync only constructs the AutoDetect transport; the probe runs on the first SendMessageAsync. + await using var session = await transport.ConnectAsync(TestContext.Current.CancellationToken); + + var ex = await Assert.ThrowsAnyAsync(() => + session.SendMessageAsync( + new JsonRpcRequest { Method = RequestMethods.Initialize, Id = new RequestId(1) }, + TestContext.Current.CancellationToken)); + + // Walk the exception chain and assert the original 415 (and its body) is somewhere in it. + // We don't pin the exact exception type so this stays robust to future error-shape tweaks, + // but the underlying status code and server body must reach the caller. + var combined = Flatten(ex); + Assert.Contains("415", combined); + Assert.Contains(streamableHttpBody, combined); + + static string Flatten(Exception e) + { + var sb = new System.Text.StringBuilder(); + void Walk(Exception? cur) + { + while (cur is not null) + { + sb.Append(cur.GetType().FullName).Append(": ").AppendLine(cur.Message); + if (cur is AggregateException agg) + { + foreach (var inner in agg.InnerExceptions) + { + Walk(inner); + } + return; + } + cur = cur.InnerException; + } + } + Walk(e); + return sb.ToString(); + } + } + + // When Streamable HTTP fails (non-JSON-RPC) and the SSE fallback also fails, the surfaced exception must remain + // an HttpRequestException carrying the original Streamable HTTP status/body, with the SSE failure as its inner. + [Fact] + public async Task AutoDetectMode_SurfacesStreamableHttpError_WithSseAsInner_WhenSseFallbackFails() + { + var options = new HttpClientTransportOptions + { + Endpoint = new Uri("http://localhost"), + TransportMode = HttpTransportMode.AutoDetect, + Name = "AutoDetect test client" + }; + + using var mockHttpHandler = new MockHttpHandler(); + using var httpClient = new HttpClient(mockHttpHandler); + await using var transport = new HttpClientTransport(options, httpClient, LoggerFactory); + + const string streamableHttpBody = "Content-Type must be 'application/json'"; + + mockHttpHandler.RequestHandler = (request) => + { + if (request.Method == HttpMethod.Post) + { + return Task.FromResult(new HttpResponseMessage + { + StatusCode = HttpStatusCode.UnsupportedMediaType, + Content = new StringContent(streamableHttpBody), + }); + } + + if (request.Method == HttpMethod.Get) + { + return Task.FromResult(new HttpResponseMessage + { + StatusCode = HttpStatusCode.MethodNotAllowed, + Content = new StringContent("Method not allowed"), + }); + } + + throw new InvalidOperationException($"Unexpected request: {request.Method}"); + }; + + await using var session = await transport.ConnectAsync(TestContext.Current.CancellationToken); + + var ex = await Assert.ThrowsAnyAsync(() => + session.SendMessageAsync( + new JsonRpcRequest { Method = RequestMethods.Initialize, Id = new RequestId(1) }, + TestContext.Current.CancellationToken)); + + // The surfaced exception is the original Streamable HTTP error (the real server diagnostic), not the SSE 405. + var httpEx = Assert.IsType(ex); + Assert.Contains("415", httpEx.Message); + Assert.Contains(streamableHttpBody, httpEx.Message); + Assert.Equal(HttpStatusCode.UnsupportedMediaType, httpEx.Data["ModelContextProtocol.HttpStatusCode"]); +#if NET + Assert.Equal(HttpStatusCode.UnsupportedMediaType, httpEx.StatusCode); +#endif + + // The SSE fallback failure (the 405 from the GET) is preserved as the inner exception, not dropped. + Assert.NotNull(httpEx.InnerException); + Assert.Contains("405", httpEx.InnerException.ToString()); + } + + // Cancellation during the AutoDetect probe must surface as an OperationCanceledException, not be masked or + // wrapped in the dual-failure AggregateException. + [Fact] + public async Task AutoDetectMode_SurfacesCancellation_WithoutWrapping() + { + var options = new HttpClientTransportOptions + { + Endpoint = new Uri("http://localhost"), + TransportMode = HttpTransportMode.AutoDetect, + Name = "AutoDetect test client" + }; + + using var mockHttpHandler = new MockHttpHandler(); + using var httpClient = new HttpClient(mockHttpHandler); + await using var transport = new HttpClientTransport(options, httpClient, LoggerFactory); + + mockHttpHandler.RequestHandler = (request) => + Task.FromResult(new HttpResponseMessage + { + StatusCode = HttpStatusCode.UnsupportedMediaType, + Content = new StringContent("Content-Type must be 'application/json'"), + }); + + await using var session = await transport.ConnectAsync(TestContext.Current.CancellationToken); + + using var cts = new CancellationTokenSource(); + cts.Cancel(); + + var ex = await Assert.ThrowsAnyAsync(() => + session.SendMessageAsync( + new JsonRpcRequest { Method = RequestMethods.Initialize, Id = new RequestId(1) }, + cts.Token)); + + Assert.IsNotType(ex); + Assert.IsAssignableFrom(ex); + } + + // The dual-failure case must be visible in logs at Warning level, even when callers swallow the exception. + [Fact] + public async Task AutoDetectMode_LogsWarning_WhenSseFallbackFailsAfterStreamableHttp() + { + var options = new HttpClientTransportOptions + { + Endpoint = new Uri("http://localhost"), + TransportMode = HttpTransportMode.AutoDetect, + Name = "AutoDetect test client" + }; + + using var mockHttpHandler = new MockHttpHandler(); + using var httpClient = new HttpClient(mockHttpHandler); + await using var transport = new HttpClientTransport(options, httpClient, LoggerFactory); + + mockHttpHandler.RequestHandler = (request) => + { + if (request.Method == HttpMethod.Post) + { + return Task.FromResult(new HttpResponseMessage + { + StatusCode = HttpStatusCode.UnsupportedMediaType, + Content = new StringContent("Content-Type must be 'application/json'"), + }); + } + + return Task.FromResult(new HttpResponseMessage + { + StatusCode = HttpStatusCode.MethodNotAllowed, + Content = new StringContent("Method not allowed"), + }); + }; + + await using var session = await transport.ConnectAsync(TestContext.Current.CancellationToken); + + await Assert.ThrowsAnyAsync(() => + session.SendMessageAsync( + new JsonRpcRequest { Method = RequestMethods.Initialize, Id = new RequestId(1) }, + TestContext.Current.CancellationToken)); + + Assert.Contains( + MockLoggerProvider.LogMessages, + m => m.LogLevel == LogLevel.Warning && m.Message.Contains("SSE fallback failed")); + } +} diff --git a/tests/ModelContextProtocol.Tests/Transport/HttpClientTransportTests.cs b/tests/ModelContextProtocol.Tests/Transport/HttpClientTransportTests.cs index 60384d3c2..a203797b7 100644 --- a/tests/ModelContextProtocol.Tests/Transport/HttpClientTransportTests.cs +++ b/tests/ModelContextProtocol.Tests/Transport/HttpClientTransportTests.cs @@ -147,6 +147,40 @@ public async Task SendMessageAsync_Handles_Accepted_Response() Assert.True(true); } + [Fact] + public async Task StreamableHttp_NotificationWithEmptyAcceptedJsonResponse_DoesNotLogParseFailure() + { + var options = new HttpClientTransportOptions + { + Endpoint = new Uri("http://localhost:8080/mcp"), + TransportMode = HttpTransportMode.StreamableHttp, + }; + + using var mockHttpHandler = new MockHttpHandler(); + using var httpClient = new HttpClient(mockHttpHandler); + await using var transport = new HttpClientTransport(options, httpClient, LoggerFactory); + + mockHttpHandler.RequestHandler = request => + { + Assert.Equal(HttpMethod.Post, request.Method); + Assert.Equal("http://localhost:8080/mcp", request.RequestUri?.AbsoluteUri); + + return Task.FromResult(new HttpResponseMessage + { + StatusCode = HttpStatusCode.Accepted, + Content = new StringContent("", Encoding.UTF8, "application/json"), + }); + }; + + await using var session = await transport.ConnectAsync(TestContext.Current.CancellationToken); + await session.SendMessageAsync( + new JsonRpcNotification { Method = "notifications/initialized" }, + TestContext.Current.CancellationToken); + + Assert.DoesNotContain(MockLoggerProvider.LogMessages, log => + log.Message.Contains("transport message parsing failed", StringComparison.Ordinal)); + } + [Fact] public async Task SendMessageAsync_Throws_HttpRequestException_With_ResponseBody_On_ErrorStatusCode() { @@ -248,6 +282,57 @@ public async Task DisposeAsync_Should_Dispose_Resources() Assert.False(transportBase.IsConnected); } + // Strict server mock used in Content-Type tests below. + // Returns 200 only for bare "application/json", otherwise 415. + private static Func> StrictJsonContentTypeHandler => + (request) => + { + if (request.Method == HttpMethod.Post) + { + var contentType = request.Content?.Headers.ContentType; + if (contentType?.CharSet is not null) + { + return Task.FromResult(new HttpResponseMessage + { + StatusCode = HttpStatusCode.UnsupportedMediaType, + Content = new StringContent("Content-Type must be 'application/json'"), + }); + } + + return Task.FromResult(new HttpResponseMessage + { + StatusCode = HttpStatusCode.OK, + Content = new StringContent( + """{"jsonrpc":"2.0","id":1,"result":{"protocolVersion":"2025-03-26","capabilities":{},"serverInfo":{"name":"Test","version":"1.0"}}}""", + Encoding.UTF8, + "application/json"), + }); + } + + throw new IOException("Abort"); + }; + + [Fact] + public async Task SendMessageAsync_StrictServer_Returns200_WhenContentTypeIsApplicationJson() + { + // Regression test for https://github.com/modelcontextprotocol/csharp-sdk/issues/1527 + // SDK must send bare "application/json" — no charset parameter. + var options = new HttpClientTransportOptions + { + Endpoint = new Uri("http://localhost:8080"), + TransportMode = HttpTransportMode.StreamableHttp, + }; + + using var mockHttpHandler = new MockHttpHandler(); + using var httpClient = new HttpClient(mockHttpHandler); + await using var transport = new HttpClientTransport(options, httpClient, LoggerFactory); + mockHttpHandler.RequestHandler = StrictJsonContentTypeHandler; + + // Succeeds only if the SDK sends Content-Type: application/json (no charset) + await using var session = await transport.ConnectAsync(TestContext.Current.CancellationToken); + Assert.NotNull(session); + } + [Fact] public async Task StreamableHttp_InitialGetSseConnection_DoesNotCountAgainstMaxReconnectionAttempts() { @@ -326,4 +411,179 @@ await session.SendMessageAsync( // Assert - Total GET requests = 1 initial connection + MaxReconnectionAttempts reconnections. Assert.Equal(1 + MaxReconnectionAttempts, getRequestCount); } -} \ No newline at end of file + + [Fact] + public async Task StreamableHttp_DisablingStandaloneGetStream_DoesNotOpenGetSseAfterInitialize() + { + var getRequestReceived = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + + var options = new HttpClientTransportOptions + { + Endpoint = new Uri("http://localhost:8080"), + TransportMode = HttpTransportMode.StreamableHttp, + EnableStandaloneGetStream = false, + }; + + using var mockHttpHandler = new MockHttpHandler(); + using var httpClient = new HttpClient(mockHttpHandler); + await using var transport = new HttpClientTransport(options, httpClient, LoggerFactory); + + mockHttpHandler.RequestHandler = (request) => + { + if (request.Method == HttpMethod.Post) + { + var response = new HttpResponseMessage + { + StatusCode = HttpStatusCode.OK, + Content = new StringContent( + """{"jsonrpc":"2.0","id":1,"result":{"protocolVersion":"2025-11-25","capabilities":{},"serverInfo":{"name":"TestServer","version":"1.0.0"}}}""", + Encoding.UTF8, + "application/json"), + }; + response.Headers.Add("Mcp-Session-Id", "test-session"); + return Task.FromResult(response); + } + + if (request.Method == HttpMethod.Get) + { + getRequestReceived.TrySetResult(true); + } + + return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)); + }; + + await using var session = await transport.ConnectAsync(TestContext.Current.CancellationToken); + await session.SendMessageAsync( + new JsonRpcRequest { Method = RequestMethods.Initialize, Id = new RequestId(1) }, + TestContext.Current.CancellationToken); + + Assert.False(getRequestReceived.Task.IsCompleted); + } + + [Fact] + public async Task StreamableHttp_DisablingStandaloneGetStream_DoesNotOpenGetSseForKnownSessionId() + { + var getRequestReceived = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + + var options = new HttpClientTransportOptions + { + Endpoint = new Uri("http://localhost:8080"), + TransportMode = HttpTransportMode.StreamableHttp, + KnownSessionId = "test-session", + EnableStandaloneGetStream = false, + }; + + using var mockHttpHandler = new MockHttpHandler(); + using var httpClient = new HttpClient(mockHttpHandler); + await using var transport = new HttpClientTransport(options, httpClient, LoggerFactory); + + mockHttpHandler.RequestHandler = (request) => + { + if (request.Method == HttpMethod.Get) + { + getRequestReceived.TrySetResult(true); + } + + return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)); + }; + + await using var session = await transport.ConnectAsync(TestContext.Current.CancellationToken); + + Assert.False(getRequestReceived.Task.IsCompleted); + } + + [Fact] + public async Task AutoDetect_DisablingStandaloneGetStream_DisposeCompletesWithHttpDetails() + { + var options = new HttpClientTransportOptions + { + Endpoint = new Uri("http://localhost:8080"), + TransportMode = HttpTransportMode.AutoDetect, + EnableStandaloneGetStream = false, + }; + + using var mockHttpHandler = new MockHttpHandler(); + using var httpClient = new HttpClient(mockHttpHandler); + await using var transport = new HttpClientTransport(options, httpClient, LoggerFactory); + + mockHttpHandler.RequestHandler = (request) => + { + if (request.Method == HttpMethod.Post) + { + var response = new HttpResponseMessage + { + StatusCode = HttpStatusCode.OK, + Content = new StringContent( + """{"jsonrpc":"2.0","id":1,"result":{"protocolVersion":"2025-11-25","capabilities":{},"serverInfo":{"name":"TestServer","version":"1.0.0"}}}""", + Encoding.UTF8, + "application/json"), + }; + response.Headers.Add("Mcp-Session-Id", "test-session"); + return Task.FromResult(response); + } + + return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)); + }; + + await using var session = await transport.ConnectAsync(TestContext.Current.CancellationToken); + await session.SendMessageAsync( + new JsonRpcRequest { Method = RequestMethods.Initialize, Id = new RequestId(1) }, + TestContext.Current.CancellationToken).WaitAsync( + TestConstants.DefaultTimeout, + TestContext.Current.CancellationToken); + Assert.True(session.MessageReader.TryRead(out var initializeResponse)); + Assert.IsType(initializeResponse); + + await session.DisposeAsync().AsTask().WaitAsync( + TestConstants.DefaultTimeout, + TestContext.Current.CancellationToken); + + Assert.True(session.MessageReader.Completion.IsCompleted); + var exception = await Assert.ThrowsAsync( + async () => await session.MessageReader.Completion); + Assert.IsType(exception.Details); + } + + [Fact] + public async Task StreamableHttp_DisablingStandaloneGetStream_StillProcessesPostSseResponses() + { + var options = new HttpClientTransportOptions + { + Endpoint = new Uri("http://localhost:8080"), + TransportMode = HttpTransportMode.StreamableHttp, + EnableStandaloneGetStream = false, + }; + + using var mockHttpHandler = new MockHttpHandler(); + using var httpClient = new HttpClient(mockHttpHandler); + await using var transport = new HttpClientTransport(options, httpClient, LoggerFactory); + + mockHttpHandler.RequestHandler = (request) => + { + if (request.Method == HttpMethod.Post) + { + var response = new HttpResponseMessage + { + StatusCode = HttpStatusCode.OK, + Content = new StringContent( + "event: message\r\n" + + """data: {"jsonrpc":"2.0","id":1,"result":{"protocolVersion":"2025-11-25","capabilities":{},"serverInfo":{"name":"TestServer","version":"1.0.0"}}}""" + + "\r\n\r\n", + Encoding.UTF8, + "text/event-stream"), + }; + response.Headers.Add("Mcp-Session-Id", "test-session"); + return Task.FromResult(response); + } + + throw new InvalidOperationException($"Unexpected request: {request.Method}"); + }; + + await using var session = await transport.ConnectAsync(TestContext.Current.CancellationToken); + await session.SendMessageAsync( + new JsonRpcRequest { Method = RequestMethods.Initialize, Id = new RequestId(1) }, + TestContext.Current.CancellationToken); + + Assert.Equal("test-session", session.SessionId); + } +} diff --git a/tests/ModelContextProtocol.Tests/Transport/StdioClientTransportTests.cs b/tests/ModelContextProtocol.Tests/Transport/StdioClientTransportTests.cs index 1a999fd14..60ce9cf5a 100644 --- a/tests/ModelContextProtocol.Tests/Transport/StdioClientTransportTests.cs +++ b/tests/ModelContextProtocol.Tests/Transport/StdioClientTransportTests.cs @@ -1,4 +1,5 @@ -using ModelContextProtocol.Client; +using Microsoft.Extensions.Logging; +using ModelContextProtocol.Client; using ModelContextProtocol.Protocol; using ModelContextProtocol.Tests.Utils; using System.IO.Pipelines; @@ -12,6 +13,42 @@ public class StdioClientTransportTests(ITestOutputHelper testOutputHelper) : Log { public static bool IsStdErrCallbackSupported => !PlatformDetection.IsMonoRuntime; + [Fact] + public async Task ConnectAsync_DoesNotLogEnvironmentVariablesAtTrace() + { + string secretName = $"MCP_TEST_SECRET_{Guid.NewGuid():N}"; + string secretValue = $"secret-{Guid.NewGuid():N}"; + + using var loggerFactory = Microsoft.Extensions.Logging.LoggerFactory.Create(builder => + { + builder.AddProvider(MockLoggerProvider); + builder.SetMinimumLevel(LogLevel.Trace); + }); + + StdioClientTransport transport = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? + new(new() + { + Command = "cmd.exe", + Arguments = ["/c", "exit /b 0"], + EnvironmentVariables = new Dictionary { [secretName] = secretValue }, + }, loggerFactory) : + new(new() + { + Command = "sh", + Arguments = ["-c", "exit 0"], + EnvironmentVariables = new Dictionary { [secretName] = secretValue }, + }, loggerFactory); + + await using var _ = await transport.ConnectAsync(TestContext.Current.CancellationToken); + + Assert.Contains(MockLoggerProvider.LogMessages, log => + log.LogLevel == LogLevel.Trace && + log.Message.Contains("starting server process", StringComparison.Ordinal)); + Assert.DoesNotContain(MockLoggerProvider.LogMessages, log => + log.Message.Contains(secretName, StringComparison.Ordinal) || + log.Message.Contains(secretValue, StringComparison.Ordinal)); + } + [Fact] public async Task CreateAsync_ValidProcessInvalidServer_Throws() { @@ -115,8 +152,12 @@ public async Task EscapesCliArgumentsCorrectly(string? cliArgumentValue) { Assert.Skip("mono runtime does not handle arguments ending with backslash correctly."); } - + + const string OutputPrefix = "CLI_ARG:"; + var capturedArgument = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); string cliArgument = $"--cli-arg={cliArgumentValue}"; + string testServerExecutable = Path.Combine(AppContext.BaseDirectory, "TestServer.exe"); + string testServerDll = Path.Combine(AppContext.BaseDirectory, "TestServer.dll"); StdioClientTransportOptions options = new() { @@ -124,30 +165,221 @@ public async Task EscapesCliArgumentsCorrectly(string? cliArgumentValue) Command = (PlatformDetection.IsMonoRuntime, PlatformDetection.IsWindows) switch { (true, _) => "mono", - (_, true) => "TestServer.exe", + (_, true) => testServerExecutable, _ => "dotnet", }, Arguments = (PlatformDetection.IsMonoRuntime, PlatformDetection.IsWindows) switch { - (true, _) => ["TestServer.exe", cliArgument], - (_, true) => [cliArgument], - _ => ["TestServer.dll", cliArgument], + (true, _) => [testServerExecutable, "--echo-cli-arg-and-exit", cliArgument], + (_, true) => ["--echo-cli-arg-and-exit", cliArgument], + _ => [testServerDll, "--echo-cli-arg-and-exit", cliArgument], + }, + StandardErrorLines = line => + { + if (line.StartsWith(OutputPrefix, StringComparison.Ordinal)) + { + capturedArgument.TrySetResult(line[OutputPrefix.Length..]); + } }, }; var transport = new StdioClientTransport(options, LoggerFactory); + await using var session = await transport.ConnectAsync(TestContext.Current.CancellationToken); + + string serializedArgument = await capturedArgument.Task.WaitAsync( + TestConstants.DefaultTimeout, + TestContext.Current.CancellationToken); + JsonElement parsedArgument = JsonElement.Parse(serializedArgument); + Assert.Equal(cliArgumentValue ?? "", parsedArgument.GetString()); + + var exception = await Assert.ThrowsAsync( + async () => await session.MessageReader.Completion.WaitAsync( + TestConstants.DefaultTimeout, + TestContext.Current.CancellationToken)); + var completionDetails = Assert.IsType(exception.Details); + Assert.Equal(0, completionDetails.ExitCode); + } + + [Fact(Skip = "Platform not supported by this test.", SkipUnless = nameof(IsStdErrCallbackSupported))] + public async Task InheritEnvironmentVariables_DefaultTrue_ChildSeesParentEnvVars() + { + // Check the same variable the False test checks for absence (HOME on Unix, USERNAME on Windows) + // so the two tests form a direct symmetric pair: one asserts it IS set, the other asserts it is NOT. + var tcs = new TaskCompletionSource(); + StdioClientTransport transport = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? + new(new() { Command = "cmd", Arguments = ["/c", "if defined USERNAME (echo USERNAME_IS_SET >&2) else (echo USERNAME_NOT_SET >&2) & exit /b 1"], StandardErrorLines = line => tcs.TrySetResult(line) }, LoggerFactory) : + new(new() { Command = "sh", Arguments = ["-c", "if [ -n \"$HOME\" ]; then echo HOME_IS_SET >&2; else echo HOME_NOT_SET >&2; fi; exit 1"], StandardErrorLines = line => tcs.TrySetResult(line) }, LoggerFactory); + + await Assert.ThrowsAnyAsync(() => McpClient.CreateAsync(transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)); + + using var cts = new CancellationTokenSource(TestConstants.DefaultTimeout); + string capturedLine = await tcs.Task.WaitAsync(cts.Token); + + Assert.Equal(RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "USERNAME_IS_SET" : "HOME_IS_SET", capturedLine.Trim()); + } + + [Fact(Skip = "Platform not supported by this test.", SkipUnless = nameof(IsStdErrCallbackSupported))] + public async Task InheritEnvironmentVariables_False_ChildDoesNotSeeParentEnvVars() + { + // Pass PATH so cmd/sh can be located. Verify that HOME (Unix) / USERNAME (Windows), + // which are always set in the parent, are absent because they were not explicitly provided. + var tcs = new TaskCompletionSource(); + StdioClientTransport transport = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? + new(new() + { + Command = "cmd", + Arguments = ["/c", "if defined USERNAME (echo USERNAME_IS_SET >&2) else (echo USERNAME_NOT_SET >&2) & exit /b 1"], + InheritEnvironmentVariables = false, + EnvironmentVariables = new Dictionary { ["PATH"] = Environment.GetEnvironmentVariable("PATH") }, + StandardErrorLines = line => tcs.TrySetResult(line) + }, LoggerFactory) : + new(new() + { + Command = "sh", + Arguments = ["-c", "if [ -n \"$HOME\" ]; then echo HOME_IS_SET >&2; else echo HOME_NOT_SET >&2; fi; exit 1"], + InheritEnvironmentVariables = false, + EnvironmentVariables = new Dictionary { ["PATH"] = Environment.GetEnvironmentVariable("PATH") }, + StandardErrorLines = line => tcs.TrySetResult(line) + }, LoggerFactory); + + await Assert.ThrowsAnyAsync(() => McpClient.CreateAsync(transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)); + + using var cts = new CancellationTokenSource(TestConstants.DefaultTimeout); + string capturedLine = await tcs.Task.WaitAsync(cts.Token); + + // HOME / USERNAME were in the parent but not passed — should be absent in the child. + Assert.Equal(RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "USERNAME_NOT_SET" : "HOME_NOT_SET", capturedLine.Trim()); + } + + [Fact(Skip = "Platform not supported by this test.", SkipUnless = nameof(IsStdErrCallbackSupported))] + public async Task InheritEnvironmentVariables_False_WithExplicitVars_ChildSeesOnlyExplicitVars() + { + // Pass PATH + one explicit var. Verify HOME (Unix) / USERNAME (Windows) is absent, + // and the explicitly provided variable is visible. + const string explicitVarName = "MCP_STDIO_TEST_EXPLICIT_VAR"; + const string explicitVarValue = "explicit_test_value"; + + var capturedLines = new List(); + var lineCount = 0; + var tcs = new TaskCompletionSource(); + void CaptureLines(string line) + { + lock (capturedLines) + { + capturedLines.Add(line.Trim()); + if (Interlocked.Increment(ref lineCount) >= 2) + tcs.TrySetResult(true); + } + } + + StdioClientTransport transport = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? + new(new() + { + Command = "cmd", + Arguments = ["/c", + $"if defined USERNAME (echo USERNAME_IS_SET >&2) else (echo USERNAME_NOT_SET >&2) " + + $"& if defined {explicitVarName} (echo EXPLICIT_IS_SET >&2) else (echo EXPLICIT_NOT_SET >&2) " + + $"& exit /b 1"], + InheritEnvironmentVariables = false, + EnvironmentVariables = new Dictionary { ["PATH"] = Environment.GetEnvironmentVariable("PATH"), [explicitVarName] = explicitVarValue }, + StandardErrorLines = CaptureLines + }, LoggerFactory) : + new(new() + { + Command = "sh", + Arguments = ["-c", + $"if [ -n \"$HOME\" ]; then echo HOME_IS_SET >&2; else echo HOME_NOT_SET >&2; fi; " + + $"if [ -n \"${explicitVarName}\" ]; then echo EXPLICIT_IS_SET >&2; else echo EXPLICIT_NOT_SET >&2; fi; exit 1"], + InheritEnvironmentVariables = false, + EnvironmentVariables = new Dictionary { ["PATH"] = Environment.GetEnvironmentVariable("PATH"), [explicitVarName] = explicitVarValue }, + StandardErrorLines = CaptureLines + }, LoggerFactory); + + await Assert.ThrowsAnyAsync(() => McpClient.CreateAsync(transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken)); + + using var cts = new CancellationTokenSource(TestConstants.DefaultTimeout); + await tcs.Task.WaitAsync(cts.Token); + + string allOutput = string.Join(Environment.NewLine, capturedLines); + Assert.Contains(RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "USERNAME_NOT_SET" : "HOME_NOT_SET", allOutput); + Assert.Contains("EXPLICIT_IS_SET", allOutput); + } + + [Fact] + public void GetDefaultEnvironmentVariables_ReturnsFreshDictionaryEachCall() + { + var first = StdioClientTransportOptions.GetDefaultEnvironmentVariables(); + var second = StdioClientTransportOptions.GetDefaultEnvironmentVariables(); + Assert.NotSame(first, second); + } + + [Fact] + public void GetDefaultEnvironmentVariables_ReturnsCorrectComparer() + { + var result = StdioClientTransportOptions.GetDefaultEnvironmentVariables(); + if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) + { + Assert.Equal(StringComparer.OrdinalIgnoreCase, result.Comparer); + } + else + { + Assert.Equal(StringComparer.Ordinal, result.Comparer); + } + } + + [Fact] + public void GetDefaultEnvironmentVariables_ContainsOnlyAllowlistedKeys() + { + HashSet allowedKeys = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) + ? new(StringComparer.OrdinalIgnoreCase) + { + "APPDATA", "HOMEDRIVE", "HOMEPATH", "LOCALAPPDATA", "PATH", "PATHEXT", + "PROCESSOR_ARCHITECTURE", "PROGRAMFILES", "SYSTEMDRIVE", "SYSTEMROOT", + "TEMP", "USERNAME", "USERPROFILE", + } + : new(StringComparer.Ordinal) + { + "HOME", "LOGNAME", "PATH", "SHELL", "TERM", "USER", + }; - // Act: Create client (handshake) and list tools to ensure full round trip works with the argument present. - await using var client = await McpClient.CreateAsync(transport, loggerFactory: LoggerFactory, cancellationToken: TestContext.Current.CancellationToken); - var tools = await client.ListToolsAsync(cancellationToken: TestContext.Current.CancellationToken); + var result = StdioClientTransportOptions.GetDefaultEnvironmentVariables(); + foreach (var key in result.Keys) + { + Assert.Contains(key, allowedKeys); + } + } - // Assert - Assert.NotNull(tools); - Assert.NotEmpty(tools); + [Fact] + public void GetDefaultEnvironmentVariables_ExcludesShellFunctionValues() + { + // Verify the postcondition: no returned values start with "()" (shell function markers). + var result = StdioClientTransportOptions.GetDefaultEnvironmentVariables(); + foreach (var kvp in result) + { + Assert.False(kvp.Value?.StartsWith("()") ?? false, + $"Value for '{kvp.Key}' starts with '()' and should have been filtered as a shell function."); + } + } + + [Fact] + public void GetDefaultEnvironmentVariables_PathIsPresent_WhenSetInEnvironment() + { + // PATH is always set in a real process environment; verify it is included. + var result = StdioClientTransportOptions.GetDefaultEnvironmentVariables(); + if (Environment.GetEnvironmentVariable("PATH") is not null) + { + Assert.True(result.ContainsKey("PATH"), "PATH should be present when it exists in the parent environment."); + } + } - var result = await client.CallToolAsync("echoCliArg", cancellationToken: TestContext.Current.CancellationToken); - var content = Assert.IsType(Assert.Single(result.Content)); - Assert.Equal(cliArgumentValue ?? "", content.Text); + [Fact] + public void GetDefaultEnvironmentVariables_DoesNotIncludeNonAllowlistedKeys() + { + // Keys that are definitely not on the allowlist must never appear. + var result = StdioClientTransportOptions.GetDefaultEnvironmentVariables(); + Assert.False(result.ContainsKey("AWS_SECRET_ACCESS_KEY")); + Assert.False(result.ContainsKey("GITHUB_TOKEN")); + Assert.False(result.ContainsKey("OPENAI_API_KEY")); } [Fact] diff --git a/tests/ModelContextProtocol.Tests/Transport/StdioServerTransportTests.cs b/tests/ModelContextProtocol.Tests/Transport/StdioServerTransportTests.cs index e47269686..42472556d 100644 --- a/tests/ModelContextProtocol.Tests/Transport/StdioServerTransportTests.cs +++ b/tests/ModelContextProtocol.Tests/Transport/StdioServerTransportTests.cs @@ -278,6 +278,55 @@ public async Task ReadMessagesAsync_Should_Accept_CRLF_Delimited_Messages() Assert.Equal("44", ((JsonRpcRequest)readMessage).Id.ToString()); } + [Fact] + public async Task ReadMessagesAsync_Should_Respond_With_ParseError_For_Request_Exceeding_MaxDepth() + { + // Build a ping request whose params nest more deeply than System.Text.Json's default + // reader MaxDepth of 64, which is what makes full deserialization throw. The request still + // carries an id, so the transport should reply with a JSON-RPC parse error for that id rather + // than dropping the request and leaving the caller pending. + var nested = new StringBuilder(); + const int depth = 100; + for (int i = 0; i < depth; i++) + { + nested.Append("{\"p").Append(i).Append("\":"); + } + nested.Append("{\"leaf\":true}"); + nested.Append('}', depth); + + var requestLine = $"{{\"jsonrpc\":\"2.0\",\"id\":900100,\"method\":\"ping\",\"params\":{nested}}}"; + + Pipe inputPipe = new(); + Pipe outputPipe = new(); + using var input = inputPipe.Reader.AsStream(); + using var output = outputPipe.Writer.AsStream(); + + await using var transport = new StreamServerTransport( + input, + output, + loggerFactory: LoggerFactory); + + await inputPipe.Writer.WriteAsync(Encoding.UTF8.GetBytes($"{requestLine}\n"), TestContext.Current.CancellationToken); + + // Read the single response line the transport writes back to the output stream. + using var responseReader = new StreamReader(outputPipe.Reader.AsStream(), Encoding.UTF8); + var responseLine = await responseReader.ReadLineAsync( +#if NET + TestContext.Current.CancellationToken +#endif + ); + + Assert.NotNull(responseLine); + + var response = JsonSerializer.Deserialize(responseLine!, McpJsonUtilities.DefaultOptions); + var error = Assert.IsType(response); + Assert.Equal("900100", error.Id.ToString()); + Assert.Equal((int)McpErrorCode.ParseError, error.Error.Code); + + // The transport should still be reading further messages after recovering from the bad one. + Assert.True(transport.IsConnected); + } + [Fact] public async Task ReadMessagesAsync_Should_Log_Received_At_Trace_Level() { diff --git a/tests/ModelContextProtocol.Tests/Transport/StreamableHttpServerTransportTests.cs b/tests/ModelContextProtocol.Tests/Transport/StreamableHttpServerTransportTests.cs new file mode 100644 index 000000000..ce2147e27 --- /dev/null +++ b/tests/ModelContextProtocol.Tests/Transport/StreamableHttpServerTransportTests.cs @@ -0,0 +1,89 @@ +using ModelContextProtocol.Protocol; +using ModelContextProtocol.Server; +using ModelContextProtocol.Tests.Utils; + +namespace ModelContextProtocol.Tests.Transport; + +public class StreamableHttpServerTransportTests(ITestOutputHelper testOutputHelper) : LoggedTest(testOutputHelper) +{ + [Fact] + public async Task SendMessageAsync_AfterGetRequestEnds_DoesNotWriteToResponseStream() + { + // Regression test for the SSE response stream being retained after the GET request + // handler returns. Without releasing the stream reference, the Kestrel connection + // and its associated memory pool buffers (~20MiB per SSE session) stay pinned in + // unmanaged memory until the session is eventually disposed (via explicit DELETE or + // idle timeout), causing steady memory growth for servers whose clients disconnect + // without sending DELETE. After the GET handler returns, SendMessageAsync must not + // attempt to write to the (now released) response stream. + + await using var transport = new StreamableHttpServerTransport() + { + SessionId = "test-session", + }; + + var responseStream = new RecordingStream(); + + using var cts = new CancellationTokenSource(); + var getTask = transport.HandleGetRequestAsync(responseStream, cts.Token); + + // Wait until the GET handler has finished initialization (signaled by the initial + // flush that sends HTTP response headers) so we know _httpSseWriter is set. + await responseStream.FirstActivity.WaitAsync(TestConstants.DefaultTimeout, TestContext.Current.CancellationToken); + + var writeCountBeforeCancel = responseStream.WriteCount; + + cts.Cancel(); + await Assert.ThrowsAnyAsync(() => getTask); + + await transport.SendMessageAsync( + new JsonRpcNotification { Method = "test" }, + TestContext.Current.CancellationToken); + + Assert.Equal(writeCountBeforeCancel, responseStream.WriteCount); + } + + private sealed class RecordingStream : Stream + { + private readonly TaskCompletionSource _firstActivity = new(TaskCreationOptions.RunContinuationsAsynchronously); + private int _writeCount; + + public Task FirstActivity => _firstActivity.Task; + public int WriteCount => Volatile.Read(ref _writeCount); + + public override bool CanRead => false; + public override bool CanSeek => false; + public override bool CanWrite => true; + public override long Length => throw new NotSupportedException(); + public override long Position + { + get => throw new NotSupportedException(); + set => throw new NotSupportedException(); + } + + public override void Flush() => _firstActivity.TrySetResult(true); + + public override Task FlushAsync(CancellationToken cancellationToken) + { + _firstActivity.TrySetResult(true); + return Task.CompletedTask; + } + + public override int Read(byte[] buffer, int offset, int count) => throw new NotSupportedException(); + public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException(); + public override void SetLength(long value) => throw new NotSupportedException(); + + public override void Write(byte[] buffer, int offset, int count) + { + Interlocked.Increment(ref _writeCount); + _firstActivity.TrySetResult(true); + } + + public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) + { + Interlocked.Increment(ref _writeCount); + _firstActivity.TrySetResult(true); + return Task.CompletedTask; + } + } +}