fix(mcp-server): Prevent double-wrapping of handlers when both API sets exist

When both legacy (tool/resource/prompt) and new (registerTool/registerResource/registerPrompt)
API methods exist on an SDK instance, and the legacy method delegates to the new method,
handlers were being wrapped twice. This caused duplicate error capture calls.

Added a __sentry_wrapped__ marker to track already-wrapped handlers and skip re-wrapping them.

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: cursoragent

packages/core/src/integrations/mcp-server/handlers.ts

@@ -41,14 +41,25 @@ function wrapMethodHandler(serverInstance: MCPServerInstance, methodName: keyof
  * @returns Wrapped handler function
  */
 function createWrappedHandler(originalHandler: MCPHandler, methodName: keyof MCPServerInstance, handlerName: string) {
-  return function (this: unknown, ...handlerArgs: unknown[]): unknown {
+  // Check if handler is already wrapped to prevent double-wrapping
+  // when both legacy and new API methods exist and one delegates to the other
+  if ((originalHandler as { __sentry_wrapped__?: boolean }).__sentry_wrapped__) {
+    return originalHandler;
+  }
+
+  const wrappedHandler = function (this: unknown, ...handlerArgs: unknown[]): unknown {
     try {
       return createErrorCapturingHandler.call(this, originalHandler, methodName, handlerName, handlerArgs);
     } catch (error) {
       DEBUG_BUILD && debug.warn('MCP handler wrapping failed:', error);
       return originalHandler.apply(this, handlerArgs);
     }
   };
+
+  // Mark the handler as wrapped
+  (wrappedHandler as { __sentry_wrapped__?: boolean }).__sentry_wrapped__ = true;
+
+  return wrappedHandler;
 }
 
 /**

packages/core/test/lib/integrations/mcp-server/mcpServerWrapper.test.ts

@@ -178,4 +178,45 @@ describe('wrapMcpServerWithSentry', () => {
       }).not.toThrow();
     });
   });
+
+  describe('Double-wrapping prevention', () => {
+    it('should not double-wrap handlers when both tool() and registerTool() exist and one delegates to the other', () => {
+      // Create a mock server with both APIs where tool() delegates to registerTool()
+      const registeredHandlers = new Map<string, any>();
+      const mockServerWithBothApis = {
+        registerTool: vi.fn((name: string, ...args: any[]) => {
+          const handler = args[args.length - 1];
+          registeredHandlers.set(name, handler);
+        }),
+        tool: vi.fn(function (this: any, name: string, handler: any) {
+          // Simulate legacy tool() delegating to registerTool()
+          return this.registerTool(name, {}, handler);
+        }),
+        resource: vi.fn(),
+        prompt: vi.fn(),
+        connect: vi.fn().mockResolvedValue(undefined),
+        server: {
+          setRequestHandler: vi.fn(),
+        },
+      };
+
+      const wrapped = wrapMcpServerWithSentry(mockServerWithBothApis);
+
+      // Register a handler via the legacy tool() method
+      const originalHandler = vi.fn();
+      wrapped.tool('test-tool', originalHandler);
+
+      // Get the registered handler
+      const registeredHandler = registeredHandlers.get('test-tool');
+
+      // The handler should be wrapped (have the __sentry_wrapped__ marker)
+      expect((registeredHandler as any).__sentry_wrapped__).toBe(true);
+
+      // Verify that calling tool() only wraps once, not twice
+      // If double-wrapped, the handler would have nested wrappers
+      // We can verify this by checking that the registered handler is the wrapped version
+      // and not a double-wrapped version
+      expect(registeredHandler).not.toBe(originalHandler);
+    });
+  });
 });