test(mcp): cover plugin tool cancellation propagation

Feelw00 · claude · Feelw00 · commit 36b9e73e38c7 · 2026-05-16T12:48:57.000+09:00
Regression test for SOL-0010 fix. Uses a real MCP SDK Client + Server
linked by InMemoryTransport (no SDK mocks) so the production wiring
(setRequestHandler callback + callTool + tool.execute) is exercised
end-to-end. Asserts that the in-flight tool receives the host's
AbortSignal and that an abort listener fires when the client cancels.

AI-assisted: drafted with claude code (claude-opus-4-7).

Co-Authored-By: Claude Opus 4.7 &lt;noreply@anthropic.com&gt;
diff --git a/src/mcp/plugin-tools-handlers.cancel.test.ts b/src/mcp/plugin-tools-handlers.cancel.test.ts
@@ -0,0 +1,73 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { describe, expect, it } from "vitest";
+import type { AnyAgentTool } from "../agents/tools/common.js";
+import { createToolsMcpServer } from "./tools-stdio-server.js";
+
+describe("plugin-tools handler forwards host cancellation to tool.execute", () => {
+  it("aborts in-flight tool.execute when client cancels the request", async () => {
+    let observedSignal: AbortSignal | undefined;
+    let abortFired = false;
+
+    const probeTool = {
+      name: "probe-cancel",
+      description: "regression probe for SOL-0010 signal propagation",
+      parameters: {},
+      ownerOnly: false,
+      execute: async (_toolCallId: string, _params: unknown, signal?: AbortSignal) => {
+        observedSignal = signal;
+        await new Promise<void>((resolve, reject) => {
+          if (!signal) {
+            // Without the fix the signal is undefined; surface that explicitly
+            // so the test fails fast instead of hanging.
+            reject(new Error("tool.execute did not receive AbortSignal"));
+            return;
+          }
+          if (signal.aborted) {
+            abortFired = true;
+            resolve();
+            return;
+          }
+          signal.addEventListener(
+            "abort",
+            () => {
+              abortFired = true;
+              resolve();
+            },
+            { once: true },
+          );
+        });
+        return { content: [{ type: "text", text: "done" }] };
+      },
+    } as unknown as AnyAgentTool;
+
+    const server = createToolsMcpServer({ name: "test", tools: [probeTool] });
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    const client = new Client({ name: "test-client", version: "0.0.0" }, { capabilities: {} });
+
+    await Promise.all([server.connect(serverTransport), client.connect(clientTransport)]);
+
+    try {
+      const controller = new AbortController();
+      const callPromise = client.callTool({ name: "probe-cancel", arguments: {} }, undefined, {
+        signal: controller.signal,
+      });
+
+      // Let the server handler invoke tool.execute and register the abort
+      // listener before we trip the controller.
+      await new Promise((r) => setTimeout(r, 20));
+      expect(observedSignal, "handler should receive AbortSignal via extra.signal").toBeInstanceOf(
+        AbortSignal,
+      );
+      expect(observedSignal?.aborted).toBe(false);
+
+      controller.abort();
+
+      await expect(callPromise).rejects.toBeDefined();
+      expect(abortFired, "tool.execute observed signal.abort event").toBe(true);
+    } finally {
+      await client.close();
+      await server.close();
+    }
+  });
+});
