drawio-mcp-server 2.0.4 → 2.1.1

package/build/real-environment/pages-and-concurrency.test.js

@@ -0,0 +1,448 @@
+import { afterAll, beforeAll, describe, expect, it } from "@jest/globals";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { createRealEnvironmentContext, disposeRealEnvironmentContext, resetDiagram, } from "./harness.js";
+import { expectNoBrowserErrors, expectNoServerErrors } from "./assertions.js";
+import { callClientToolRaw, callClientToolJson, callToolJson, callToolRaw, } from "./tools.js";
+import { expectToolSuccess, unwrapToolPayload } from "./test-helpers.js";
+function extractPrimaryText(result) {
+    return (result.content.find((item) => item.type === "text" &&
+        (item.text?.includes("mxGraphModel") || item.text?.includes("<svg")))?.text ?? "");
+}
+async function createHttpClient(context, name) {
+    const client = new Client({
+        name,
+        version: "1.0.0",
+    });
+    const transport = new StreamableHTTPClientTransport(new URL(`http://localhost:${context.httpPort}/mcp`));
+    await client.connect(transport);
+    return client;
+}
+describe("real environment/pages and concurrency", () => {
+    let context;
+    beforeAll(async () => {
+        context = await createRealEnvironmentContext();
+    }, 180000);
+    afterAll(async () => {
+        await disposeRealEnvironmentContext(context);
+    });
+    it("supports page listing and serializes concurrent page-targeted edits", async () => {
+        await resetDiagram(context);
+        context.browserMessages.length = 0;
+        const logCountBefore = context.logger.entries.length;
+        const { payload: renamedFirstPayload } = await callToolJson(context, "rename-page", {
+            page: { index: 0 },
+            name: "Page Alpha",
+        });
+        expectToolSuccess(renamedFirstPayload);
+        const pageAlpha = unwrapToolPayload(renamedFirstPayload);
+        expect(pageAlpha.is_current).toBe(true);
+        const { payload: createdPayload } = await callToolJson(context, "create-page", {
+            name: "Page Beta Draft",
+        });
+        expectToolSuccess(createdPayload);
+        const pageBeta = unwrapToolPayload(createdPayload);
+        expect(pageBeta.is_current).toBe(false);
+        const { payload: currentAfterCreatePayload } = await callToolJson(context, "get-current-page", {});
+        expectToolSuccess(currentAfterCreatePayload);
+        const currentAfterCreate = unwrapToolPayload(currentAfterCreatePayload);
+        expect(currentAfterCreate.id).toBe(pageAlpha.id);
+        const { payload: renamedBetaPayload } = await callToolJson(context, "rename-page", {
+            page: { id: pageBeta.id },
+            name: "Page Beta",
+        });
+        expectToolSuccess(renamedBetaPayload);
+        const renamedBeta = unwrapToolPayload(renamedBetaPayload);
+        expect(renamedBeta).toMatchObject({
+            id: pageBeta.id,
+            name: "Page Beta",
+            is_current: false,
+        });
+        const { payload: currentAfterRenamePayload } = await callToolJson(context, "get-current-page", {});
+        expectToolSuccess(currentAfterRenamePayload);
+        const currentAfterRename = unwrapToolPayload(currentAfterRenamePayload);
+        expect(currentAfterRename.id).toBe(pageAlpha.id);
+        const importXml = '<mxGraphModel dx="0" dy="0" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="850" pageHeight="1100" math="0" shadow="0"><root><mxCell id="0"/><mxCell id="1" parent="0"/><mxCell id="gamma-seed" value="Gamma Seed" style="rounded=1;whiteSpace=wrap;html=1;fillColor=#ffe6cc;strokeColor=#d79b00;" vertex="1" parent="1"><mxGeometry x="80" y="120" width="180" height="80" as="geometry"/></mxCell></root></mxGraphModel>';
+        const { payload: importPayload } = await callToolJson(context, "import-diagram", {
+            data: importXml,
+            format: "xml",
+            mode: "new-page",
+            filename: "Page Gamma.drawio",
+        });
+        expectToolSuccess(importPayload);
+        const importResult = unwrapToolPayload(importPayload);
+        expect(importResult.success).toBe(true);
+        expect(importResult.pages).toBe(3);
+        const { payload: pagesPayload } = await callToolJson(context, "list-pages", {});
+        expectToolSuccess(pagesPayload);
+        const pages = unwrapToolPayload(pagesPayload);
+        expect(pages).toEqual([
+            {
+                index: 0,
+                id: pageAlpha.id,
+                name: "Page Alpha",
+                is_current: false,
+            },
+            {
+                index: 1,
+                id: pageBeta.id,
+                name: "Page Beta",
+                is_current: false,
+            },
+            {
+                index: 2,
+                id: pages[2].id,
+                name: "Page Gamma",
+                is_current: true,
+            },
+        ]);
+        const missingTargetPage = await context.client.callTool({
+            name: "add-rectangle",
+            arguments: {
+                text: "Missing target page",
+            },
+        });
+        expect(missingTargetPage.isError).toBe(true);
+        expect(missingTargetPage.content[0]
+            ?.text).toContain("target_page");
+        const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+        const secondServer = context.app.createMcpServer();
+        const secondClient = new Client({
+            name: "page-concurrency-client",
+            version: "1.0.0",
+        });
+        await Promise.all([
+            secondServer.connect(serverTransport),
+            secondClient.connect(clientTransport),
+        ]);
+        try {
+            const { payload: alphaRectPayload } = await callToolJson(context, "add-rectangle", {
+                target_page: { id: pageAlpha.id },
+                x: 80,
+                y: 80,
+                width: 180,
+                height: 80,
+                text: "Alpha Seed",
+            });
+            expectToolSuccess(alphaRectPayload);
+            const alphaRect = unwrapToolPayload(alphaRectPayload);
+            const { payload: betaRectPayload } = await callClientToolJson(secondClient, "add-rectangle", {
+                target_page: { id: pageBeta.id },
+                x: 120,
+                y: 120,
+                width: 180,
+                height: 80,
+                text: "Beta Seed",
+            });
+            expectToolSuccess(betaRectPayload);
+            const betaRect = unwrapToolPayload(betaRectPayload);
+            await Promise.all([
+                callToolJson(context, "edit-cell", {
+                    target_page: { id: pageAlpha.id },
+                    cell_id: alphaRect.id,
+                    text: "Alpha Updated",
+                }),
+                callClientToolJson(secondClient, "edit-cell", {
+                    target_page: { id: pageBeta.id },
+                    cell_id: betaRect.id,
+                    text: "Beta Updated",
+                }),
+            ]);
+            const { payload: betaLayerPayload } = await callClientToolJson(secondClient, "create-layer", {
+                target_page: { id: pageBeta.id },
+                name: "Beta Background Layer",
+            });
+            expectToolSuccess(betaLayerPayload);
+            const betaLayer = unwrapToolPayload(betaLayerPayload);
+            await callClientToolJson(secondClient, "move-cell-to-layer", {
+                target_page: { id: pageBeta.id },
+                cell_id: betaRect.id,
+                target_layer_id: betaLayer.id,
+            });
+            const { payload: betaModelPayload } = await callClientToolJson(secondClient, "list-paged-model", {
+                target_page: { id: pageBeta.id },
+                filter: {
+                    ids: [betaRect.id],
+                },
+                page: 0,
+                page_size: 10,
+            });
+            expectToolSuccess(betaModelPayload);
+            const betaModel = unwrapToolPayload(betaModelPayload);
+            const betaCells = Array.isArray(betaModel?.cells)
+                ? betaModel.cells
+                : Array.isArray(betaModel)
+                    ? betaModel
+                    : [];
+            expect(betaCells).toHaveLength(1);
+            expect(betaCells[0]?.layer?.id).toBe(betaLayer.id);
+        }
+        finally {
+            await secondClient.close();
+        }
+        const { payload: currentPagePayload } = await callToolJson(context, "get-current-page", {});
+        expectToolSuccess(currentPagePayload);
+        const currentPage = unwrapToolPayload(currentPagePayload);
+        expect(currentPage.id).toBe(pages[2].id);
+        const alphaExport = await callToolRaw(context, "export-diagram", {
+            target_page: { id: pageAlpha.id },
+            format: "xml",
+            size: "page",
+        });
+        const betaExport = await callToolRaw(context, "export-diagram", {
+            target_page: { id: pageBeta.id },
+            format: "xml",
+            size: "page",
+        });
+        const gammaExport = await callToolRaw(context, "export-diagram", {
+            target_page: { id: pages[2].id },
+            format: "xml",
+            size: "page",
+        });
+        const alphaXml = extractPrimaryText(alphaExport);
+        const betaXml = extractPrimaryText(betaExport);
+        const gammaXml = extractPrimaryText(gammaExport);
+        expect(alphaXml).toContain("Alpha Updated");
+        expect(alphaXml).not.toContain("Beta Updated");
+        expect(alphaXml).not.toContain("Gamma Seed");
+        expect(betaXml).toContain("Beta Updated");
+        expect(betaXml).not.toContain("Alpha Updated");
+        expect(betaXml).not.toContain("Gamma Seed");
+        expect(gammaXml).toContain("Gamma Seed");
+        expect(gammaXml).not.toContain("Alpha Updated");
+        expect(gammaXml).not.toContain("Beta Updated");
+        await callToolJson(context, "get-selected-cell", {
+            target_page: { id: pageAlpha.id },
+        });
+        const { payload: currentAfterVisibleToolPayload } = await callToolJson(context, "get-current-page", {});
+        expectToolSuccess(currentAfterVisibleToolPayload);
+        const currentAfterVisibleTool = unwrapToolPayload(currentAfterVisibleToolPayload);
+        expect(currentAfterVisibleTool.id).toBe(pageAlpha.id);
+        const betaSvgExport = await callToolRaw(context, "export-diagram", {
+            target_page: { id: pageBeta.id },
+            format: "svg",
+            size: "page",
+            embed_xml: true,
+        });
+        const betaSvg = extractPrimaryText(betaSvgExport);
+        expect(betaSvg).toContain("<svg");
+        expect(betaSvg).toContain("Beta Updated");
+        expect(betaSvg).not.toContain("Alpha Updated");
+        const { payload: currentAfterEmbeddedExportPayload } = await callToolJson(context, "get-current-page", {});
+        expectToolSuccess(currentAfterEmbeddedExportPayload);
+        const currentAfterEmbeddedExport = unwrapToolPayload(currentAfterEmbeddedExportPayload);
+        expect(currentAfterEmbeddedExport.id).toBe(pageAlpha.id);
+        await expectNoBrowserErrors(context, "pages-and-concurrency");
+        await expectNoServerErrors(context, "pages-and-concurrency", logCountBefore);
+    }, 180000);
+    it("copies a page for derivative edits without changing the source page", async () => {
+        await resetDiagram(context);
+        context.browserMessages.length = 0;
+        const logCountBefore = context.logger.entries.length;
+        const { payload: renamedSourcePayload } = await callToolJson(context, "rename-page", {
+            page: { index: 0 },
+            name: "Template Page",
+        });
+        expectToolSuccess(renamedSourcePayload);
+        const sourcePage = unwrapToolPayload(renamedSourcePayload);
+        await callToolJson(context, "add-rectangle", {
+            target_page: { id: sourcePage.id },
+            x: 100,
+            y: 120,
+            width: 210,
+            height: 90,
+            text: "Template Seed",
+        });
+        const { payload: tailPagePayload } = await callToolJson(context, "create-page", {
+            name: "Existing Tail Page",
+        });
+        expectToolSuccess(tailPagePayload);
+        const tailPage = unwrapToolPayload(tailPagePayload);
+        const { payload: pagesBeforeCopyPayload } = await callToolJson(context, "list-pages", {});
+        expectToolSuccess(pagesBeforeCopyPayload);
+        const pagesBeforeCopy = unwrapToolPayload(pagesBeforeCopyPayload);
+        const { payload: copiedPagePayload } = await callToolJson(context, "copy-page", {
+            page: { id: sourcePage.id },
+            name: "Template Variant",
+        });
+        expectToolSuccess(copiedPagePayload);
+        const copiedPage = unwrapToolPayload(copiedPagePayload);
+        expect(copiedPage).toMatchObject({
+            name: "Template Variant",
+            is_current: false,
+        });
+        const { payload: pagesAfterCopyPayload } = await callToolJson(context, "list-pages", {});
+        expectToolSuccess(pagesAfterCopyPayload);
+        const pagesAfterCopy = unwrapToolPayload(pagesAfterCopyPayload);
+        expect(pagesAfterCopy.map((page) => page.id)).toEqual([
+            ...pagesBeforeCopy.map((page) => page.id),
+            copiedPage.id,
+        ]);
+        expect(copiedPage.index).toBe(pagesBeforeCopy.length);
+        expect(pagesAfterCopy.find((page) => page.id === tailPage.id)?.index).toBe(tailPage.index);
+        const { payload: currentAfterCopyPayload } = await callToolJson(context, "get-current-page", {});
+        expectToolSuccess(currentAfterCopyPayload);
+        const currentAfterCopy = unwrapToolPayload(currentAfterCopyPayload);
+        expect(currentAfterCopy.id).toBe(sourcePage.id);
+        await callToolJson(context, "add-rectangle", {
+            target_page: { id: copiedPage.id },
+            x: 360,
+            y: 120,
+            width: 210,
+            height: 90,
+            text: "Variant Only",
+        });
+        const sourceExport = await callToolRaw(context, "export-diagram", {
+            target_page: { id: sourcePage.id },
+            format: "xml",
+            size: "page",
+        });
+        const copiedExport = await callToolRaw(context, "export-diagram", {
+            target_page: { id: copiedPage.id },
+            format: "xml",
+            size: "page",
+        });
+        const sourceXml = extractPrimaryText(sourceExport);
+        const copiedXml = extractPrimaryText(copiedExport);
+        expect(sourceXml).toContain("Template Seed");
+        expect(sourceXml).not.toContain("Variant Only");
+        expect(copiedXml).toContain("Template Seed");
+        expect(copiedXml).toContain("Variant Only");
+        await expectNoBrowserErrors(context, "copy-page");
+        await expectNoServerErrors(context, "copy-page", logCountBefore);
+    }, 180000);
+});
+describe("real environment/pages and concurrency over HTTP", () => {
+    let context;
+    beforeAll(async () => {
+        context = await createRealEnvironmentContext();
+    }, 180000);
+    afterAll(async () => {
+        await disposeRealEnvironmentContext(context);
+    });
+    it("serializes concurrent writes from three HTTP clients across three pages", async () => {
+        await resetDiagram(context);
+        context.browserMessages.length = 0;
+        const logCountBefore = context.logger.entries.length;
+        const { payload: renamedFirstPayload } = await callToolJson(context, "rename-page", {
+            page: { index: 0 },
+            name: "HTTP Page One",
+        });
+        expectToolSuccess(renamedFirstPayload);
+        const pageOne = unwrapToolPayload(renamedFirstPayload);
+        expect(pageOne.is_current).toBe(true);
+        const { payload: createdSecondPayload } = await callToolJson(context, "create-page", {
+            name: "HTTP Page Two",
+        });
+        expectToolSuccess(createdSecondPayload);
+        const pageTwo = unwrapToolPayload(createdSecondPayload);
+        expect(pageTwo.is_current).toBe(false);
+        const { payload: createdThirdPayload } = await callToolJson(context, "create-page", {
+            name: "HTTP Page Three",
+        });
+        expectToolSuccess(createdThirdPayload);
+        const pageThree = unwrapToolPayload(createdThirdPayload);
+        expect(pageThree.is_current).toBe(false);
+        const { payload: currentAfterCreatePayload } = await callToolJson(context, "get-current-page", {});
+        expectToolSuccess(currentAfterCreatePayload);
+        const currentAfterCreate = unwrapToolPayload(currentAfterCreatePayload);
+        expect(currentAfterCreate.id).toBe(pageOne.id);
+        const clients = [
+            await createHttpClient(context, "http-page-client-1"),
+            await createHttpClient(context, "http-page-client-2"),
+            await createHttpClient(context, "http-page-client-3"),
+        ];
+        try {
+            const [clientOne, clientTwo, clientThree] = clients;
+            const [pageOneRectPayload, pageTwoRectPayload, pageThreeRectPayload] = await Promise.all([
+                callClientToolJson(clientOne, "add-rectangle", {
+                    target_page: { id: pageOne.id },
+                    x: 60,
+                    y: 80,
+                    width: 210,
+                    height: 90,
+                    text: "HTTP One Seed",
+                }),
+                callClientToolJson(clientTwo, "add-rectangle", {
+                    target_page: { id: pageTwo.id },
+                    x: 100,
+                    y: 120,
+                    width: 210,
+                    height: 90,
+                    text: "HTTP Two Seed",
+                }),
+                callClientToolJson(clientThree, "add-rectangle", {
+                    target_page: { id: pageThree.id },
+                    x: 140,
+                    y: 160,
+                    width: 210,
+                    height: 90,
+                    text: "HTTP Three Seed",
+                }),
+            ]);
+            const pageOneRect = unwrapToolPayload(pageOneRectPayload.payload);
+            const pageTwoRect = unwrapToolPayload(pageTwoRectPayload.payload);
+            const pageThreeRect = unwrapToolPayload(pageThreeRectPayload.payload);
+            await Promise.all([
+                callClientToolJson(clientOne, "edit-cell", {
+                    target_page: { id: pageOne.id },
+                    cell_id: pageOneRect.id,
+                    text: "HTTP One Final",
+                }),
+                callClientToolJson(clientTwo, "edit-cell", {
+                    target_page: { id: pageTwo.id },
+                    cell_id: pageTwoRect.id,
+                    text: "HTTP Two Final",
+                }),
+                callClientToolJson(clientThree, "edit-cell", {
+                    target_page: { id: pageThree.id },
+                    cell_id: pageThreeRect.id,
+                    text: "HTTP Three Final",
+                }),
+            ]);
+            const { payload: currentPagePayload } = await callToolJson(context, "get-current-page", {});
+            expectToolSuccess(currentPagePayload);
+            const currentPage = unwrapToolPayload(currentPagePayload);
+            expect(currentPage.id).toBe(pageOne.id);
+            const [pageOneExport, pageTwoExport, pageThreeExport] = await Promise.all([
+                callClientToolRaw(clientOne, "export-diagram", {
+                    target_page: { id: pageOne.id },
+                    format: "xml",
+                    size: "page",
+                }),
+                callClientToolRaw(clientTwo, "export-diagram", {
+                    target_page: { id: pageTwo.id },
+                    format: "xml",
+                    size: "page",
+                }),
+                callClientToolRaw(clientThree, "export-diagram", {
+                    target_page: { id: pageThree.id },
+                    format: "xml",
+                    size: "page",
+                }),
+            ]);
+            const pageOneXml = extractPrimaryText(pageOneExport);
+            const pageTwoXml = extractPrimaryText(pageTwoExport);
+            const pageThreeXml = extractPrimaryText(pageThreeExport);
+            expect(pageOneXml).toContain("HTTP One Final");
+            expect(pageOneXml).not.toContain("HTTP Two Final");
+            expect(pageOneXml).not.toContain("HTTP Three Final");
+            expect(pageTwoXml).toContain("HTTP Two Final");
+            expect(pageTwoXml).not.toContain("HTTP One Final");
+            expect(pageTwoXml).not.toContain("HTTP Three Final");
+            expect(pageThreeXml).toContain("HTTP Three Final");
+            expect(pageThreeXml).not.toContain("HTTP One Final");
+            expect(pageThreeXml).not.toContain("HTTP Two Final");
+            const { payload: currentAfterExportsPayload } = await callToolJson(context, "get-current-page", {});
+            expectToolSuccess(currentAfterExportsPayload);
+            const currentAfterExports = unwrapToolPayload(currentAfterExportsPayload);
+            expect(currentAfterExports.id).toBe(pageOne.id);
+        }
+        finally {
+            await Promise.all(clients.map((client) => client.close()));
+        }
+        await expectNoBrowserErrors(context, "pages-and-concurrency-http");
+        await expectNoServerErrors(context, "pages-and-concurrency-http", logCountBefore);
+    }, 180000);
+});

package/build/real-environment/shapes.test.js

@@ -150,4 +150,62 @@ describe("real environment/shapes", () => {
         await expectNoBrowserErrors(context, "shapes-aws-lambda-set-cell-shape");
         await expectNoServerErrors(context, "shapes-aws-lambda-set-cell-shape", logCountBefore);
     }, 180000);
+    const vendorCases = [
+        {
+            label: "GCP search marker",
+            shape_name: "mxgraph.gcp2.search",
+            keyFragment: "mxgraph.gcp2.search",
+        },
+        {
+            label: "Azure compute Virtual_Machine",
+            shape_name: "mxgraph.azure2.compute.virtual_machine",
+            keyFragment: "Virtual_Machine.svg",
+        },
+        {
+            label: "Cisco19 l2_switch",
+            shape_name: "mxgraph.cisco19.l2_switch",
+            keyFragment: "prIcon=l2_switch",
+        },
+        {
+            label: "CiscoSafe capability anti_malware",
+            shape_name: "mxgraph.cisco_safe.capability.anti_malware",
+            keyFragment: "mxgraph.cisco_safe.capability.anti_malware",
+        },
+    ];
+    for (const vendorCase of vendorCases) {
+        it(`resolves and renders ${vendorCase.label} from runtime-extracted catalog`, async () => {
+            await resetDiagram(context);
+            context.browserMessages.length = 0;
+            const logCountBefore = context.logger.entries.length;
+            const { payload: shapeByNamePayload } = await callToolJson(context, "get-shape-by-name", { shape_name: vendorCase.shape_name });
+            const shapeByName = unwrapToolPayload(shapeByNamePayload);
+            expect(shapeByName).toBeDefined();
+            expect(shapeByName).not.toBeNull();
+            expect(String(shapeByName?.style ?? "")).toContain(vendorCase.keyFragment);
+            const { payload } = await callToolJson(context, "add-cell-of-shape", {
+                shape_name: vendorCase.shape_name,
+                text: vendorCase.label,
+                x: 200,
+                y: 160,
+                width: 120,
+                height: 120,
+            });
+            expectToolSuccess(payload);
+            const screenshotLabel = `shapes-${vendorCase.shape_name.replace(/[^a-z0-9]+/gi, "-")}`;
+            await withVerificationScreenshot(context, screenshotLabel, "before-live-state-verification", async () => {
+                const exportedXml = await context.page.evaluate(() => {
+                    const maybeWindow = window;
+                    const editor = maybeWindow.ui?.editor;
+                    const xmlNode = editor?.getGraphXml?.();
+                    return window.mxUtils?.getXml?.(xmlNode) ?? "";
+                });
+                const cell = await getCellById(context.page, payload.result.id);
+                expect(cell).not.toBeNull();
+                expect(exportedXml).toContain(`id="${payload.result.id}"`);
+                expect(exportedXml).toContain(vendorCase.keyFragment);
+            });
+            await expectNoBrowserErrors(context, screenshotLabel);
+            await expectNoServerErrors(context, screenshotLabel, logCountBefore);
+        }, 180000);
+    }
 });

package/build/real-environment/tools.js

@@ -1,8 +1,47 @@
 import { expect } from "@jest/globals";
-export async function callToolJson(context, name, args) {
-    const result = (await context.client.callTool({
+const PAGE_SCOPED_TOOL_NAMES = new Set([
+    "get-selected-cell",
+    "add-rectangle",
+    "add-edge",
+    "delete-cell-by-id",
+    "add-cell-of-shape",
+    "set-cell-shape",
+    "set-cell-data",
+    "edit-cell",
+    "edit-edge",
+    "list-paged-model",
+    "list-layers",
+    "set-active-layer",
+    "move-cell-to-layer",
+    "get-active-layer",
+    "create-layer",
+    "set-cell-parent",
+    "export-diagram",
+    "import-diagram",
+    "import-mermaid",
+]);
+function withDefaultTargetPage(name, args) {
+    if (!PAGE_SCOPED_TOOL_NAMES.has(name)) {
+        return args;
+    }
+    if (name === "import-diagram" && args.mode === "new-page") {
+        return args;
+    }
+    if (name === "import-mermaid" && args.insert_mode === "new-page") {
+        return args;
+    }
+    if (args.target_page) {
+        return args;
+    }
+    return {
+        target_page: { index: 0 },
+        ...args,
+    };
+}
+export async function callClientToolJson(client, name, args) {
+    const result = (await client.callTool({
         name,
-        arguments: args,
+        arguments: withDefaultTargetPage(name, args),
     }));
     expect(result.isError).not.toBe(true);
     const content = result.content;
@@ -12,11 +51,17 @@ export async function callToolJson(context, name, args) {
         payload: JSON.parse(String(content[0]?.text ?? "{}")),
     };
 }
-export async function callToolRaw(context, name, args) {
-    const result = (await context.client.callTool({
+export async function callToolJson(context, name, args) {
+    return callClientToolJson(context.client, name, args);
+}
+export async function callClientToolRaw(client, name, args) {
+    const result = (await client.callTool({
         name,
-        arguments: args,
+        arguments: withDefaultTargetPage(name, args),
     }));
     expect(result.isError).not.toBe(true);
     return result;
 }
+export async function callToolRaw(context, name, args) {
+    return callClientToolRaw(context.client, name, args);
+}

package/build/register-tool.js

@@ -0,0 +1,83 @@
+import { stripSchemaRecursively } from "./strip-schema.js";
+/**
+ * Wraps an `McpServer` so that the `tools/list` response strips the
+ * `$schema` key from every tool's `inputSchema` and `outputSchema`.
+ *
+ * Why this is necessary:
+ *
+ * - The MCP SDK lazily serializes tool schemas: it stores the Zod object
+ *   verbatim at registration time and only converts to JSON Schema
+ *   (via `zodToJsonSchema` / `z4mini.toJSONSchema`) when a client issues
+ *   `tools/list`. The conversion emits a top-level
+ *   `"$schema": "http://json-schema.org/draft-07/schema#"` field.
+ *
+ * - Claude Code's MCP ingest layer can't tolerate the `$` character in
+ *   schema keys (Anthropic's parameter-name regex is
+ *   `^[a-zA-Z0-9_.-]{1,64}$`). When `$schema` is present, the entire
+ *   `properties` object is dropped, leaving tools effectively schemaless.
+ *   The user can see the tool name but the LLM has no way to know which
+ *   arguments to send, so calls fail at runtime.
+ *
+ * - A previous attempt at this fix tried to strip `$schema` from the
+ *   stored `_registeredTools[name].inputSchema` via `setTimeout(0)`.
+ *   That was a no-op against modern SDKs because the stored value at
+ *   that point is the raw Zod object (which doesn't have `$schema`).
+ *   The `$schema` key is added by `toJsonSchemaCompat` at serialization
+ *   time, not at registration time.
+ *
+ * The fix here intercepts the `tools/list` request handler that the SDK
+ * registers internally on the first `server.tool(...)` call, and wraps
+ * it so the response runs through `stripSchemaRecursively` before being
+ * returned to the client.
+ */
+export function createServerWithSchemaStripping(server) {
+    const originalTool = server.tool.bind(server);
+    let patched = false;
+    server.tool = function tool(...args) {
+        const result = originalTool(...args);
+        // The SDK lazily registers the tools/list handler on the first
+        // server.tool() call (via setToolRequestHandlers). After that call
+        // returns, the handler is in place and we can wrap it.
+        if (!patched) {
+            patched = true;
+            patchToolsListHandler(server);
+        }
+        return result;
+    };
+    return server;
+}
+function patchToolsListHandler(server) {
+    // The McpServer wraps an inner Server (the low-level protocol layer).
+    // Its `_requestHandlers` Map stores per-method handlers keyed by the
+    // method name literal (e.g. "tools/list").
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const innerServer = server.server;
+    const handlers = innerServer?._requestHandlers;
+    if (!handlers) {
+        // SDK internals changed; fail closed (no-op) so we don't crash the
+        // server. The tools will still work but schemas will leak `$schema`.
+        return;
+    }
+    const original = handlers.get("tools/list");
+    if (!original) {
+        return;
+    }
+    handlers.set("tools/list", async (...callArgs) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const response = await original(...callArgs);
+        if (response && Array.isArray(response.tools)) {
+            response.tools = response.tools.map(stripToolSchemas);
+        }
+        return response;
+    });
+}
+function stripToolSchemas(tool) {
+    const next = { ...tool };
+    if (next.inputSchema) {
+        next.inputSchema = stripSchemaRecursively(next.inputSchema);
+    }
+    if (next.outputSchema) {
+        next.outputSchema = stripSchemaRecursively(next.outputSchema);
+    }
+    return next;
+}