SEP-2106: traceability YAML + JSON Schema 2020-12 conformance checks (#295)

* chore: add SEP-2106 requirement-traceability YAML (tools JSON Schema 2020-12)

* Drop structured-content text-fallback row from SEP-2106

That SHOULD predates SEP-2106 (pre-existing context line in tools.mdx); 2106
only relaxes structuredContent to allow non-object values (permissive). Point
spec_url at the SEP doc security section where the remaining obligations live.

* feat: SEP-2106 JSON Schema 2020-12 vocabulary preservation checks

Extend the json-schema-2020-12 server scenario (previously SEP-1613 only) with
three checks that verify the broader JSON Schema 2020-12 vocabulary SEP-2106
permits in a tool inputSchema survives tools/list rather than being stripped:
composition (allOf/anyOf), conditional (if/then/else), and reference ($anchor)
keywords.

- everything-server: add these keywords to json_schema_2020_12_tool's raw schema
- add a negative-test server (sep-2106-stripped-schema.ts) plus a negative test
  asserting the checks emit FAILURE when the vocabulary is stripped

* feat: SEP-2106 client scenario for network $ref dereferencing

Add json-schema-ref-no-deref, a client-suite scenario that advertises a tool
whose inputSchema contains a $ref pointing at a canary URL hosted by the
scenario. The sep-2106-no-network-ref-deref check fails if the client fetches
the canary while processing the schema, covering the SEP-2106 requirement that
implementations MUST NOT automatically dereference network-URI $ref values.

- register the scenario in the client scenarios list
- everything-client: handle the scenario with the basic connect+listTools flow
- tests: compliant client passes, a deliberately dereferencing client is
  caught, and a client that never lists tools cannot pass

* Address review findings in SEP-2106 scenarios

- json-schema-ref-deref: make getChecks() idempotent (fresh array per call,
  matching the http-standard-headers convention) and guard the async /mcp
  handler like the example servers do
- json-schema-2020-12: include the SEP-2106 keywords ($anchor, allOf/anyOf,
  if/then/else) in the description's example inputSchema so a server that
  copies it verbatim passes the new checks
- sep-2106-stripped-schema: default to port 3007 to match negative.test.ts and
  avoid sharing a default with sep-2549-no-caching-hints

* Soft-gate SEP-2106 keyword checks on the negotiated protocol version

The json-schema-2020-12 scenario is introducedIn 2025-11-25 (SEP-1613) but the
three SEP-2106 keyword-preservation checks test draft-era behavior. Rather than
failing servers that only negotiated 2025-11-25, gate the failure on the wire
protocolVersion from the initialize handshake: preserved keywords are SUCCESS at
any version, stripped keywords are FAILURE only when the server negotiated the
draft version and SKIPPED otherwise.

The published SDK does not advertise the draft version yet, so the negative test
asserts SKIPPED for the stripped-schema server; the FAILURE branch is covered by
unit tests on sep2106KeywordCheckStatus.

src/scenarios/server/negative.test.ts

@@ -3,6 +3,11 @@ import path from 'path';
 import { DNSRebindingProtectionScenario } from './dns-rebinding';
 import { ResourcesNotFoundErrorScenario } from './resources';
 import { CachingScenario } from './caching';
+import {
+  JsonSchema2020_12Scenario,
+  sep2106KeywordCheckStatus
+} from './json-schema-2020-12';
+import { DRAFT_PROTOCOL_VERSION, LATEST_SPEC_VERSION } from '../../types';
 
 function startServer(scriptPath: string, port: number): Promise<ChildProcess> {
   return new Promise((resolve, reject) => {
@@ -148,4 +153,75 @@ describe('Server scenario negative tests', () => {
       }
     }, 15000);
   });
+
+  describe('json-schema-2020-12 (SEP-2106)', () => {
+    let serverProcess: ChildProcess | null = null;
+    const PORT = 3007;
+
+    beforeAll(async () => {
+      serverProcess = await startServer(
+        path.join(
+          process.cwd(),
+          'examples/servers/typescript/sep-2106-stripped-schema.ts'
+        ),
+        PORT
+      );
+    }, 35000);
+
+    afterAll(async () => {
+      await stopServer(serverProcess);
+    });
+
+    it('flags SEP-2106 keyword-preservation checks against a server that strips the 2020-12 vocabulary', async () => {
+      const scenario = new JsonSchema2020_12Scenario();
+      const checks = await scenario.run(`http://localhost:${PORT}/mcp`);
+
+      // The tool is still advertised, so it must be found...
+      const found = checks.find(
+        (c) => c.id === 'json-schema-2020-12-tool-found'
+      );
+      expect(found?.status).toBe('SUCCESS');
+
+      // ...but the stripped 2020-12 keywords must be flagged. The stripped
+      // server negotiates 2025-11-25 (the published SDK does not advertise the
+      // draft protocol version), so the soft version gate reports SKIPPED
+      // rather than FAILURE — see sep2106KeywordCheckStatus.
+      const composition = checks.find(
+        (c) => c.id === 'sep-2106-composition-keywords-preserved'
+      );
+      expect(composition?.status).toBe('SKIPPED');
+
+      const conditional = checks.find(
+        (c) => c.id === 'sep-2106-conditional-keywords-preserved'
+      );
+      expect(conditional?.status).toBe('SKIPPED');
+
+      const anchor = checks.find(
+        (c) => c.id === 'sep-2106-anchor-keyword-preserved'
+      );
+      expect(anchor?.status).toBe('SKIPPED');
+    }, 10000);
+  });
+
+  describe('sep2106KeywordCheckStatus (soft version gate)', () => {
+    it('passes preserved keywords at any negotiated version', () => {
+      expect(sep2106KeywordCheckStatus(true, DRAFT_PROTOCOL_VERSION)).toBe(
+        'SUCCESS'
+      );
+      expect(sep2106KeywordCheckStatus(true, LATEST_SPEC_VERSION)).toBe(
+        'SUCCESS'
+      );
+      expect(sep2106KeywordCheckStatus(true, undefined)).toBe('SUCCESS');
+    });
+
+    it('fails stripped keywords only when the server negotiated the draft version', () => {
+      expect(sep2106KeywordCheckStatus(false, DRAFT_PROTOCOL_VERSION)).toBe(
+        'FAILURE'
+      );
+      expect(sep2106KeywordCheckStatus(false, LATEST_SPEC_VERSION)).toBe(
+        'SKIPPED'
+      );
+      expect(sep2106KeywordCheckStatus(false, undefined)).toBe('SKIPPED');
+    });
+  });
 });