feat(SocketModeReceiver): expose Socket Mode timeout and reconnect options

SocketModeClient accepts clientPingTimeout, serverPingTimeout,
pingPongLoggingEnabled, and autoReconnectEnabled, but SocketModeReceiver
does not pass these through, forcing users to accept hardcoded defaults.

This is problematic because Slack's servers frequently take >5000ms to
respond to pings (see #2496), causing unnecessary disconnections with
the default 5000ms clientPingTimeout.

Changes:
- Add clientPingTimeout, serverPingTimeout, pingPongLoggingEnabled, and
  autoReconnectEnabled to SocketModeReceiverOptions interface
- Pass these options through to the SocketModeClient constructor
- Add tests verifying option passthrough and backward compatibility

Fixes #2496

Author: shivasymbl

src/receivers/SocketModeReceiver.ts

@@ -39,6 +39,10 @@ export interface SocketModeReceiverOptions {
   installerOptions?: InstallerOptions;
   appToken: string; // App Level Token
   customRoutes?: CustomRoute[];
+  clientPingTimeout?: number;
+  serverPingTimeout?: number;
+  pingPongLoggingEnabled?: boolean;
+  autoReconnectEnabled?: boolean;
   // biome-ignore lint/suspicious/noExplicitAny: user-provided custom properties can be anything
   customPropertiesExtractor?: (args: any) => StringIndexed;
   processEventErrorHandler?: (args: SocketModeReceiverProcessEventErrorHandlerArgs) => Promise<boolean>;
@@ -96,6 +100,10 @@ export default class SocketModeReceiver implements Receiver {
     appToken,
     logger = undefined,
     logLevel = LogLevel.INFO,
+    clientPingTimeout = undefined,
+    serverPingTimeout = undefined,
+    pingPongLoggingEnabled = undefined,
+    autoReconnectEnabled = undefined,
     clientId = undefined,
     clientSecret = undefined,
     stateSecret = undefined,
@@ -111,6 +119,10 @@ export default class SocketModeReceiver implements Receiver {
       appToken,
       logLevel,
       logger,
+      clientPingTimeout,
+      serverPingTimeout,
+      pingPongLoggingEnabled,
+      autoReconnectEnabled,
       clientOptions: installerOptions.clientOptions,
     });
 

test/unit/receivers/SocketModeReceiver.spec.ts

@@ -1,3 +1,4 @@
+import { EventEmitter } from 'node:events';
 import { IncomingMessage, ServerResponse } from 'node:http';
 import path from 'node:path';
 import { InstallProvider } from '@slack/oauth';
@@ -96,6 +97,115 @@ describe('SocketModeReceiver', () => {
       });
       assert.isNotNull(receiver);
     });
+    it('should pass clientPingTimeout to SocketModeClient', async () => {
+      const constructorSpy = sinon.spy();
+      class FakeSocketModeClient extends EventEmitter {
+        // biome-ignore lint/suspicious/noExplicitAny: test mock
+        constructor(opts: any) {
+          super();
+          constructorSpy(opts);
+        }
+      }
+      const smOverrides = mergeOverrides(overrides, {
+        '@slack/socket-mode': {
+          SocketModeClient: FakeSocketModeClient,
+        },
+      });
+      const SocketModeReceiver = importSocketModeReceiver(smOverrides);
+      const receiver = new SocketModeReceiver({
+        appToken: 'my-secret',
+        logger: noopLogger,
+        clientPingTimeout: 15000,
+      });
+      assert.isNotNull(receiver);
+      sinon.assert.calledOnce(constructorSpy);
+      const constructorArgs = constructorSpy.firstCall.args[0];
+      assert.equal(constructorArgs.clientPingTimeout, 15000);
+    });
+    it('should pass serverPingTimeout to SocketModeClient', async () => {
+      const constructorSpy = sinon.spy();
+      class FakeSocketModeClient extends EventEmitter {
+        // biome-ignore lint/suspicious/noExplicitAny: test mock
+        constructor(opts: any) {
+          super();
+          constructorSpy(opts);
+        }
+      }
+      const smOverrides = mergeOverrides(overrides, {
+        '@slack/socket-mode': {
+          SocketModeClient: FakeSocketModeClient,
+        },
+      });
+      const SocketModeReceiver = importSocketModeReceiver(smOverrides);
+      const receiver = new SocketModeReceiver({
+        appToken: 'my-secret',
+        logger: noopLogger,
+        serverPingTimeout: 60000,
+      });
+      assert.isNotNull(receiver);
+      sinon.assert.calledOnce(constructorSpy);
+      const constructorArgs = constructorSpy.firstCall.args[0];
+      assert.equal(constructorArgs.serverPingTimeout, 60000);
+    });
+    it('should pass all socket mode timeout options to SocketModeClient', async () => {
+      const constructorSpy = sinon.spy();
+      class FakeSocketModeClient extends EventEmitter {
+        // biome-ignore lint/suspicious/noExplicitAny: test mock
+        constructor(opts: any) {
+          super();
+          constructorSpy(opts);
+        }
+      }
+      const smOverrides = mergeOverrides(overrides, {
+        '@slack/socket-mode': {
+          SocketModeClient: FakeSocketModeClient,
+        },
+      });
+      const SocketModeReceiver = importSocketModeReceiver(smOverrides);
+      const receiver = new SocketModeReceiver({
+        appToken: 'my-secret',
+        logger: noopLogger,
+        clientPingTimeout: 15000,
+        serverPingTimeout: 60000,
+        pingPongLoggingEnabled: true,
+        autoReconnectEnabled: false,
+      });
+      assert.isNotNull(receiver);
+      sinon.assert.calledOnce(constructorSpy);
+      const constructorArgs = constructorSpy.firstCall.args[0];
+      assert.equal(constructorArgs.clientPingTimeout, 15000);
+      assert.equal(constructorArgs.serverPingTimeout, 60000);
+      assert.equal(constructorArgs.pingPongLoggingEnabled, true);
+      assert.equal(constructorArgs.autoReconnectEnabled, false);
+    });
+    it('should use defaults when socket mode timeout options are not provided', async () => {
+      const constructorSpy = sinon.spy();
+      class FakeSocketModeClient extends EventEmitter {
+        // biome-ignore lint/suspicious/noExplicitAny: test mock
+        constructor(opts: any) {
+          super();
+          constructorSpy(opts);
+        }
+      }
+      const smOverrides = mergeOverrides(overrides, {
+        '@slack/socket-mode': {
+          SocketModeClient: FakeSocketModeClient,
+        },
+      });
+      const SocketModeReceiver = importSocketModeReceiver(smOverrides);
+      const receiver = new SocketModeReceiver({
+        appToken: 'my-secret',
+        logger: noopLogger,
+      });
+      assert.isNotNull(receiver);
+      sinon.assert.calledOnce(constructorSpy);
+      const constructorArgs = constructorSpy.firstCall.args[0];
+      assert.equal(constructorArgs.appToken, 'my-secret');
+      assert.isUndefined(constructorArgs.clientPingTimeout);
+      assert.isUndefined(constructorArgs.serverPingTimeout);
+      assert.isUndefined(constructorArgs.pingPongLoggingEnabled);
+      assert.isUndefined(constructorArgs.autoReconnectEnabled);
+    });
     it('should throw an error if redirect uri options supplied invalid or incomplete', async () => {
       const SocketModeReceiver = importSocketModeReceiver(overrides);
       const clientId = 'my-clientId';