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
  */
 functioncreateWrappedHandler(originalHandler: MCPHandler,methodName: keyofMCPServerInstance,handlerName: string){
-returnfunction(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((originalHandleras{__sentry_wrapped__?: boolean}).__sentry_wrapped__){
+returnoriginalHandler;
+}
+
+constwrappedHandler=function(this: unknown, ...handlerArgs: unknown[]): unknown{
 try{
 returncreateErrorCapturingHandler.call(this,originalHandler,methodName,handlerName,handlerArgs);
 }catch(error){
 DEBUG_BUILD&&debug.warn('MCP handler wrapping failed:',error);
 returnoriginalHandler.apply(this,handlerArgs);
 }
 };
+
+// Mark the handler as wrapped
+(wrappedHandleras{__sentry_wrapped__?: boolean}).__sentry_wrapped__=true;
+
+returnwrappedHandler;
 }
 
 /**

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()
+constregisteredHandlers=newMap<string,any>();
+constmockServerWithBothApis={
+registerTool: vi.fn((name: string, ...args: any[])=>{
+consthandler=args[args.length-1];
+registeredHandlers.set(name,handler);
+}),
+tool: vi.fn(function(this: any,name: string,handler: any){
+// Simulate legacy tool() delegating to registerTool()
+returnthis.registerTool(name,{},handler);
+}),
+resource: vi.fn(),
+prompt: vi.fn(),
+connect: vi.fn().mockResolvedValue(undefined),
+server: {
+setRequestHandler: vi.fn(),
+},
+};
+
+constwrapped=wrapMcpServerWithSentry(mockServerWithBothApis);
+
+// Register a handler via the legacy tool() method
+constoriginalHandler=vi.fn();
+wrapped.tool('test-tool',originalHandler);
+
+// Get the registered handler
+constregisteredHandler=registeredHandlers.get('test-tool');
+
+// The handler should be wrapped (have the __sentry_wrapped__ marker)
+expect((registeredHandlerasany).__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);
+});
+});
 });

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

@@ -41,14 +41,25 @@ function wrapMethodHandler(serverInstance: MCPServerInstance, methodName: keyof
  * @returns Wrapped handler function
  */
 functioncreateWrappedHandler(originalHandler: MCPHandler,methodName: keyofMCPServerInstance,handlerName: string){
-returnfunction(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((originalHandleras{__sentry_wrapped__?: boolean}).__sentry_wrapped__){
+returnoriginalHandler;
+}
+
+constwrappedHandler=function(this: unknown, ...handlerArgs: unknown[]): unknown{
 try{
 returncreateErrorCapturingHandler.call(this,originalHandler,methodName,handlerName,handlerArgs);
 }catch(error){
 DEBUG_BUILD&&debug.warn('MCP handler wrapping failed:',error);
 returnoriginalHandler.apply(this,handlerArgs);
 }
 };
+
+// Mark the handler as wrapped
+(wrappedHandleras{__sentry_wrapped__?: boolean}).__sentry_wrapped__=true;
+
+returnwrappedHandler;
 }
 
 /**

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()
+constregisteredHandlers=newMap<string,any>();
+constmockServerWithBothApis={
+registerTool: vi.fn((name: string, ...args: any[])=>{
+consthandler=args[args.length-1];
+registeredHandlers.set(name,handler);
+}),
+tool: vi.fn(function(this: any,name: string,handler: any){
+// Simulate legacy tool() delegating to registerTool()
+returnthis.registerTool(name,{},handler);
+}),
+resource: vi.fn(),
+prompt: vi.fn(),
+connect: vi.fn().mockResolvedValue(undefined),
+server: {
+setRequestHandler: vi.fn(),
+},
+};
+
+constwrapped=wrapMcpServerWithSentry(mockServerWithBothApis);
+
+// Register a handler via the legacy tool() method
+constoriginalHandler=vi.fn();
+wrapped.tool('test-tool',originalHandler);
+
+// Get the registered handler
+constregisteredHandler=registeredHandlers.get('test-tool');
+
+// The handler should be wrapped (have the __sentry_wrapped__ marker)
+expect((registeredHandlerasany).__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);
+});
+});
 });

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

@@ -41,14 +41,25 @@ function wrapMethodHandler(serverInstance: MCPServerInstance, methodName: keyof
  * @returns Wrapped handler function
  */
 functioncreateWrappedHandler(originalHandler: MCPHandler,methodName: keyofMCPServerInstance,handlerName: string){
-returnfunction(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((originalHandleras{__sentry_wrapped__?: boolean}).__sentry_wrapped__){
+returnoriginalHandler;
+}
+
+constwrappedHandler=function(this: unknown, ...handlerArgs: unknown[]): unknown{
 try{
 returncreateErrorCapturingHandler.call(this,originalHandler,methodName,handlerName,handlerArgs);
 }catch(error){
 DEBUG_BUILD&&debug.warn('MCP handler wrapping failed:',error);
 returnoriginalHandler.apply(this,handlerArgs);
 }
 };
+
+// Mark the handler as wrapped
+(wrappedHandleras{__sentry_wrapped__?: boolean}).__sentry_wrapped__=true;
+
+returnwrappedHandler;
 }
 
 /**

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()
+constregisteredHandlers=newMap<string,any>();
+constmockServerWithBothApis={
+registerTool: vi.fn((name: string, ...args: any[])=>{
+consthandler=args[args.length-1];
+registeredHandlers.set(name,handler);
+}),
+tool: vi.fn(function(this: any,name: string,handler: any){
+// Simulate legacy tool() delegating to registerTool()
+returnthis.registerTool(name,{},handler);
+}),
+resource: vi.fn(),
+prompt: vi.fn(),
+connect: vi.fn().mockResolvedValue(undefined),
+server: {
+setRequestHandler: vi.fn(),
+},
+};
+
+constwrapped=wrapMcpServerWithSentry(mockServerWithBothApis);
+
+// Register a handler via the legacy tool() method
+constoriginalHandler=vi.fn();
+wrapped.tool('test-tool',originalHandler);
+
+// Get the registered handler
+constregisteredHandler=registeredHandlers.get('test-tool');
+
+// The handler should be wrapped (have the __sentry_wrapped__ marker)
+expect((registeredHandlerasany).__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);
+});
+});
 });

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

@@ -41,14 +41,25 @@ function wrapMethodHandler(serverInstance: MCPServerInstance, methodName: keyof
  * @returns Wrapped handler function
  */
 functioncreateWrappedHandler(originalHandler: MCPHandler,methodName: keyofMCPServerInstance,handlerName: string){
-returnfunction(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((originalHandleras{__sentry_wrapped__?: boolean}).__sentry_wrapped__){
+returnoriginalHandler;
+}
+
+constwrappedHandler=function(this: unknown, ...handlerArgs: unknown[]): unknown{
 try{
 returncreateErrorCapturingHandler.call(this,originalHandler,methodName,handlerName,handlerArgs);
 }catch(error){
 DEBUG_BUILD&&debug.warn('MCP handler wrapping failed:',error);
 returnoriginalHandler.apply(this,handlerArgs);
 }
 };
+
+// Mark the handler as wrapped
+(wrappedHandleras{__sentry_wrapped__?: boolean}).__sentry_wrapped__=true;
+
+returnwrappedHandler;
 }
 
 /**

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()
+constregisteredHandlers=newMap<string,any>();
+constmockServerWithBothApis={
+registerTool: vi.fn((name: string, ...args: any[])=>{
+consthandler=args[args.length-1];
+registeredHandlers.set(name,handler);
+}),
+tool: vi.fn(function(this: any,name: string,handler: any){
+// Simulate legacy tool() delegating to registerTool()
+returnthis.registerTool(name,{},handler);
+}),
+resource: vi.fn(),
+prompt: vi.fn(),
+connect: vi.fn().mockResolvedValue(undefined),
+server: {
+setRequestHandler: vi.fn(),
+},
+};
+
+constwrapped=wrapMcpServerWithSentry(mockServerWithBothApis);
+
+// Register a handler via the legacy tool() method
+constoriginalHandler=vi.fn();
+wrapped.tool('test-tool',originalHandler);
+
+// Get the registered handler
+constregisteredHandler=registeredHandlers.get('test-tool');
+
+// The handler should be wrapped (have the __sentry_wrapped__ marker)
+expect((registeredHandlerasany).__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);
+});
+});
 });

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

@@ -41,14 +41,25 @@ function wrapMethodHandler(serverInstance: MCPServerInstance, methodName: keyof
  * @returns Wrapped handler function
  */
 functioncreateWrappedHandler(originalHandler: MCPHandler,methodName: keyofMCPServerInstance,handlerName: string){
-returnfunction(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((originalHandleras{__sentry_wrapped__?: boolean}).__sentry_wrapped__){
+returnoriginalHandler;
+}
+
+constwrappedHandler=function(this: unknown, ...handlerArgs: unknown[]): unknown{
 try{
 returncreateErrorCapturingHandler.call(this,originalHandler,methodName,handlerName,handlerArgs);
 }catch(error){
 DEBUG_BUILD&&debug.warn('MCP handler wrapping failed:',error);
 returnoriginalHandler.apply(this,handlerArgs);
 }
 };
+
+// Mark the handler as wrapped
+(wrappedHandleras{__sentry_wrapped__?: boolean}).__sentry_wrapped__=true;
+
+returnwrappedHandler;
 }
 
 /**

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()
+constregisteredHandlers=newMap<string,any>();
+constmockServerWithBothApis={
+registerTool: vi.fn((name: string, ...args: any[])=>{
+consthandler=args[args.length-1];
+registeredHandlers.set(name,handler);
+}),
+tool: vi.fn(function(this: any,name: string,handler: any){
+// Simulate legacy tool() delegating to registerTool()
+returnthis.registerTool(name,{},handler);
+}),
+resource: vi.fn(),
+prompt: vi.fn(),
+connect: vi.fn().mockResolvedValue(undefined),
+server: {
+setRequestHandler: vi.fn(),
+},
+};
+
+constwrapped=wrapMcpServerWithSentry(mockServerWithBothApis);
+
+// Register a handler via the legacy tool() method
+constoriginalHandler=vi.fn();
+wrapped.tool('test-tool',originalHandler);
+
+// Get the registered handler
+constregisteredHandler=registeredHandlers.get('test-tool');
+
+// The handler should be wrapped (have the __sentry_wrapped__ marker)
+expect((registeredHandlerasany).__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);
+});
+});
 });

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

@@ -41,14 +41,25 @@ function wrapMethodHandler(serverInstance: MCPServerInstance, methodName: keyof
  * @returns Wrapped handler function
  */
 functioncreateWrappedHandler(originalHandler: MCPHandler,methodName: keyofMCPServerInstance,handlerName: string){
-returnfunction(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((originalHandleras{__sentry_wrapped__?: boolean}).__sentry_wrapped__){
+returnoriginalHandler;
+}
+
+constwrappedHandler=function(this: unknown, ...handlerArgs: unknown[]): unknown{
 try{
 returncreateErrorCapturingHandler.call(this,originalHandler,methodName,handlerName,handlerArgs);
 }catch(error){
 DEBUG_BUILD&&debug.warn('MCP handler wrapping failed:',error);
 returnoriginalHandler.apply(this,handlerArgs);
 }
 };
+
+// Mark the handler as wrapped
+(wrappedHandleras{__sentry_wrapped__?: boolean}).__sentry_wrapped__=true;
+
+returnwrappedHandler;
 }
 
 /**

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()
+constregisteredHandlers=newMap<string,any>();
+constmockServerWithBothApis={
+registerTool: vi.fn((name: string, ...args: any[])=>{
+consthandler=args[args.length-1];
+registeredHandlers.set(name,handler);
+}),
+tool: vi.fn(function(this: any,name: string,handler: any){
+// Simulate legacy tool() delegating to registerTool()
+returnthis.registerTool(name,{},handler);
+}),
+resource: vi.fn(),
+prompt: vi.fn(),
+connect: vi.fn().mockResolvedValue(undefined),
+server: {
+setRequestHandler: vi.fn(),
+},
+};
+
+constwrapped=wrapMcpServerWithSentry(mockServerWithBothApis);
+
+// Register a handler via the legacy tool() method
+constoriginalHandler=vi.fn();
+wrapped.tool('test-tool',originalHandler);
+
+// Get the registered handler
+constregisteredHandler=registeredHandlers.get('test-tool');
+
+// The handler should be wrapped (have the __sentry_wrapped__ marker)
+expect((registeredHandlerasany).__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);
+});
+});
 });

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

@@ -41,14 +41,25 @@ function wrapMethodHandler(serverInstance: MCPServerInstance, methodName: keyof
  * @returns Wrapped handler function
  */
 functioncreateWrappedHandler(originalHandler: MCPHandler,methodName: keyofMCPServerInstance,handlerName: string){
-returnfunction(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((originalHandleras{__sentry_wrapped__?: boolean}).__sentry_wrapped__){
+returnoriginalHandler;
+}
+
+constwrappedHandler=function(this: unknown, ...handlerArgs: unknown[]): unknown{
 try{
 returncreateErrorCapturingHandler.call(this,originalHandler,methodName,handlerName,handlerArgs);
 }catch(error){
 DEBUG_BUILD&&debug.warn('MCP handler wrapping failed:',error);
 returnoriginalHandler.apply(this,handlerArgs);
 }
 };
+
+// Mark the handler as wrapped
+(wrappedHandleras{__sentry_wrapped__?: boolean}).__sentry_wrapped__=true;
+
+returnwrappedHandler;
 }
 
 /**

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()
+constregisteredHandlers=newMap<string,any>();
+constmockServerWithBothApis={
+registerTool: vi.fn((name: string, ...args: any[])=>{
+consthandler=args[args.length-1];
+registeredHandlers.set(name,handler);
+}),
+tool: vi.fn(function(this: any,name: string,handler: any){
+// Simulate legacy tool() delegating to registerTool()
+returnthis.registerTool(name,{},handler);
+}),
+resource: vi.fn(),
+prompt: vi.fn(),
+connect: vi.fn().mockResolvedValue(undefined),
+server: {
+setRequestHandler: vi.fn(),
+},
+};
+
+constwrapped=wrapMcpServerWithSentry(mockServerWithBothApis);
+
+// Register a handler via the legacy tool() method
+constoriginalHandler=vi.fn();
+wrapped.tool('test-tool',originalHandler);
+
+// Get the registered handler
+constregisteredHandler=registeredHandlers.get('test-tool');
+
+// The handler should be wrapped (have the __sentry_wrapped__ marker)
+expect((registeredHandlerasany).__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);
+});
+});
 });

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

@@ -41,14 +41,25 @@ function wrapMethodHandler(serverInstance: MCPServerInstance, methodName: keyof
  * @returns Wrapped handler function
  */
 functioncreateWrappedHandler(originalHandler: MCPHandler,methodName: keyofMCPServerInstance,handlerName: string){
-returnfunction(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((originalHandleras{__sentry_wrapped__?: boolean}).__sentry_wrapped__){
+returnoriginalHandler;
+}
+
+constwrappedHandler=function(this: unknown, ...handlerArgs: unknown[]): unknown{
 try{
 returncreateErrorCapturingHandler.call(this,originalHandler,methodName,handlerName,handlerArgs);
 }catch(error){
 DEBUG_BUILD&&debug.warn('MCP handler wrapping failed:',error);
 returnoriginalHandler.apply(this,handlerArgs);
 }
 };
+
+// Mark the handler as wrapped
+(wrappedHandleras{__sentry_wrapped__?: boolean}).__sentry_wrapped__=true;
+
+returnwrappedHandler;
 }
 
 /**

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()
+constregisteredHandlers=newMap<string,any>();
+constmockServerWithBothApis={
+registerTool: vi.fn((name: string, ...args: any[])=>{
+consthandler=args[args.length-1];
+registeredHandlers.set(name,handler);
+}),
+tool: vi.fn(function(this: any,name: string,handler: any){
+// Simulate legacy tool() delegating to registerTool()
+returnthis.registerTool(name,{},handler);
+}),
+resource: vi.fn(),
+prompt: vi.fn(),
+connect: vi.fn().mockResolvedValue(undefined),
+server: {
+setRequestHandler: vi.fn(),
+},
+};
+
+constwrapped=wrapMcpServerWithSentry(mockServerWithBothApis);
+
+// Register a handler via the legacy tool() method
+constoriginalHandler=vi.fn();
+wrapped.tool('test-tool',originalHandler);
+
+// Get the registered handler
+constregisteredHandler=registeredHandlers.get('test-tool');
+
+// The handler should be wrapped (have the __sentry_wrapped__ marker)
+expect((registeredHandlerasany).__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);
+});
+});
 });