Protocol versions

import { test, expect } from "@frontmcp/testing";
import { FrontMcpInstance } from "@frontmcp/sdk";
import { config } from "./main";

test("server/discover lists every revision the server speaks", async ({ mcp }) => {
  const { result } = (await mcp.raw.request({ jsonrpc: "2.0", id: 1, method: "server/discover" })) as any;
  expect(result.supportedVersions).toEqual(["2026-07-28", "2025-11-25", "2025-06-18", "2025-03-26", "2024-11-05"]);
});

test("a revision FrontMCP doesn't know: 400 and -32022, with the ones it does", async () => {
  const server = await FrontMcpInstance.createFetchHandler(config);
  const response = await server(listTools("2099-01-01", "2099-01-01"));
  expect(response.status).toBe(400);
  expect((await response.json()).error).toEqual({
    code: -32022,
    message: "Unsupported protocol version: 2099-01-01",
    data: { supported: ["2026-07-28", "2025-11-25", "2025-06-18", "2025-03-26", "2024-11-05"], requested: "2099-01-01" },
  });
});

test("a header and a body that disagree: 400 and -32020", async () => {
  const server = await FrontMcpInstance.createFetchHandler(config);
  const response = await server(listTools("2026-07-28", "2025-11-25"));
  expect(response.status).toBe(400);
  expect((await response.json()).error).toEqual({
    code: -32020,
    message: "Header mismatch: mcp-protocol-version header value '2026-07-28' does not match body value '2025-11-25'",
  });
});

/** A tools/list that names one revision in its header and another in its body. */
function listTools(header: string, body: string) {
  return new Request("https://desk.example.com/", {
    method: "POST",
    headers: { "content-type": "application/json", "mcp-protocol-version": header, "mcp-method": "tools/list" },
    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list", params: { _meta: { "io.modelcontextprotocol/protocolVersion": body } } }),
  });
}

import { test, expect } from "@frontmcp/testing";
import { FrontMcpInstance } from "@frontmcp/sdk";
import { config } from "./main";

const call = { jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: "search_tickets", arguments: { query: "log" } } };
const post = (headers: Record<string, string>) =>
  new Request("https://desk.example.com/", { method: "POST", headers: { "content-type": "application/json", ...headers }, body: JSON.stringify(call) });

test("a bare call is served as 2026-07-28", async () => {
  const server = await FrontMcpInstance.createFetchHandler(config);
  const response = await server(post({}));
  expect(response.status).toBe(200);
  expect((await response.json()).result).toMatchObject({ resultType: "complete", structuredContent: { query: "log", tickets: [] } });
});

test("a header it does send must still match the body", async () => {
  const server = await FrontMcpInstance.createFetchHandler(config);
  const response = await server(post({ "mcp-name": "close_ticket" }));
  expect(response.status).toBe(400);
  expect((await response.json()).error.message).toBe("Header mismatch: mcp-name header value 'close_ticket' does not match body value 'search_tickets'");
});

import { test, expect } from "@frontmcp/testing";
import { FrontMcpInstance } from "@frontmcp/sdk";
import { config } from "./main";

test("the stream starts by saying what it will carry", async () => {
  const server = await FrontMcpInstance.createFetchHandler(config);
  const wanted = { toolsListChanged: true, promptsListChanged: true, resourcesListChanged: true, resourceSubscriptions: ["desk://queue"] };
  const response = await server(listen(wanted));
  expect(response.headers.get("content-type")).toContain("text/event-stream");

  const stream = response.body!.getReader();
  expect(await nextMessage(stream)).toEqual({
    jsonrpc: "2.0",
    method: "notifications/subscriptions/acknowledged",
    params: {
      // No promptsListChanged: the server has no prompts.
      notifications: { toolsListChanged: true, resourcesListChanged: true, resourceSubscriptions: ["desk://queue"] },
      _meta: { "io.modelcontextprotocol/subscriptionId": 7 },
    },
  });
  void stream.cancel(); // the client goes away
});

function listen(notifications: Record<string, unknown>) {
  return new Request("https://desk.example.com/", {
    method: "POST",
    headers: { "content-type": "application/json", accept: "text/event-stream", "mcp-protocol-version": "2026-07-28", "mcp-method": "subscriptions/listen" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: 7,
      method: "subscriptions/listen",
      params: { notifications, _meta: { "io.modelcontextprotocol/protocolVersion": "2026-07-28" } },
    }),
  });
}

// The next message on the stream, or null when none comes within 200 ms.
async function nextMessage(stream: ReadableStreamDefaultReader<Uint8Array>) {
  const chunk = await Promise.race([stream.read(), new Promise<null>((resolve) => setTimeout(() => resolve(null), 200))]);
  if (!chunk || chunk.done) return null;
  const data = new TextDecoder().decode(chunk.value).split("\n").find((line) => line.startsWith("data: "));
  return data ? JSON.parse(data.slice("data: ".length)) : null;
}

import { test, expect } from "@frontmcp/testing";
import { FrontMcpInstance, McpStatelessClient } from "@frontmcp/sdk";
import { config } from "./main";

async function connect(options: Partial<ConstructorParameters<typeof McpStatelessClient>[0]> = {}) {
  const server = await FrontMcpInstance.createFetchHandler(config);
  return new McpStatelessClient({
    url: "https://desk.example.com/",
    // Hands each request to the server above, so this runs here. A real client leaves it out.
    fetchImpl: (url, init) => server(new Request(url, init)),
    ...options,
  });
}

test("discover() and listTools()", async () => {
  const desk = await connect();
  expect((await desk.discover()).supportedVersions).toContain("2026-07-28");
  expect((await desk.listTools()).map((tool) => tool.name)).toEqual(["close_ticket"]);
});

test("callTool() answers the tool's question, and resolves with the result", async () => {
  const asked: unknown[] = [];
  const desk = await connect({
    capabilities: { elicitation: { form: {} } },
    handlers: {
      onElicit: async (params) => {
        asked.push(params.message);
        return { action: "accept", content: { confirm: true } };
      },
    },
  });
  const result = await desk.callTool("close_ticket", { id: "T-1" });
  expect(asked).toEqual(["Close ticket T-1?"]);
  expect(result.structuredContent).toEqual({ id: "T-1", status: "closed" });
});

test("without the elicitation capability, the call fails with -32021", async () => {
  const desk = await connect();
  await expect(desk.callTool("close_ticket", { id: "T-1" })).rejects.toMatchObject({
    name: "McpStatelessError",
    code: -32021,
    message: "This request requires the `elicitation` client capability",
  });
});