Socket Mode Timeout

[GhouI]

(Filling out the following with as much detail as you can provide will help us solve your issue sooner.)

Packages:

Select all that apply:

• @slack/web-api
• @slack/rtm-api
• @slack/webhooks
• @slack/oauth
• @slack/socket-mode
• @slack/types
• I don't know

Reproducible in:

The Slack SDK version

(Paste the output of)

npm ls | grep -o "\S\+@\S\+$" | tr @ ' ' | awk -v q='"' '{print q$1q": "q"^"$2q","}' | grep slack
"slack/bolt": "^3.22.0",
"slack/web-api": "^7.12.0",

or refer to your package.json

Node.js runtime version

(Paste the output of node --version)

OS info

(Paste the output of sw_vers && uname -v on macOS/Linux or ver on Windows OS)
It is hosted on railway.

Steps to reproduce:

(Share the commands to run, source code, and project settings)

1.The issue is that after a long period of time of idle the socket mode doesn't work. meaning its attempting to hit the slack api but nothing

Expected result:

Not having an socket api error

Error:
[INFO] socket-mode:SocketModeClient:0 Going to establish a new connection to Slack ...
[INFO] web-api:WebClient:0 API Call failed due to rate limiting. Will retry in 10 seconds.

Actual result:

Requirements

For general questions/issues about Slack API platform or its server-side, could you submit questions at https://my.slack.com/help/requests/new instead. 🙇

I have looked at past threads and issues. They say X above is resolved in that issue but nope.
Please read the Contributing guidelines and Code of Conduct before creating this issue or pull request. By submitting, you are agreeing to those rules.

[mwbrooks]

Hi @GhouI 👋🏻

Thanks for the details and screenshot included in your issue. 🙇🏻

I noticed that you're using "slack/bolt": "^3.22.0". This version is over a year old and uses @slack/socket-mode@1.3.6.

Unfortunately, @slack/socket-mode@1.3.6 has 2 known issues related to the socket connection timing out and disconnecting: #2099 and #2094. Both of these issues were resolved in @slack/socket-mode@2.0.3 and newer (see full release notes).

---

I have 2 suggested solutions for you:

1. Quick Solution: Upgrade to the latest Socket Mode Receiver

You can continue to use your older version of Bolt, but upgrade to the latest Socket Mode Receiver.

1. Add the latest @slack/socket-mode to your package.json by running: npm install @slack/socket-mode
   • Confirm that you have "@slack/socket-mode": "^2.0.5" (or newer) added to your package.json`
2. Follow the Custom Socket Mode Receiver documentation to use the latest Socket Mode receiver instead of the older version bundled with Bolt.

const { SocketModeClient } = require('@slack/socket-mode');

const socketModeReceiver = new SocketModeReceiver({
  appToken: process.env.APP_TOKEN,

  // enable the following if you want to use OAuth
  // clientId: process.env.CLIENT_ID,
  // clientSecret: process.env.CLIENT_SECRET,
  // stateSecret: process.env.STATE_SECRET,
  // scopes: ['channels:read', 'chat:write', 'app_mentions:read', 'channels:manage', 'commands'],
});

const app = new App({
  receiver: socketModeReceiver,
  // ...
});

2. Recommended Solution: Upgrade to latest Bolt 4.0

After following the 1. Quick Solution above and confirming that the latest Socket Mode resolves your issues, then you may want to consider upgrading to the latest Bolt. There are a few breaking changes when upgrading from 3.x to 4.x that are described in the Release Notes. If you're impacted by the breaking changes, then you can follow the migration guide that's also included in the release notes.

Hope that helps! 👍🏻

[GhouI]

Thanks for your reply. I have deployed the solution and will monitor it for 24–48 hours, as that’s usually when the bot stops connecting to Slack. If everything remains fine, I will close this thread.

[mwbrooks]

Thanks and good luck @GhouI!

[GhouI]

@mwbrooks
Hi, I have deployed the project onto my server and here is the issue.

TDLR: It keeps timing out even after no one mentions the bot by doing @.

Here is some of my sort code.
Package.json

{
  "dependencies": {
    "@anthropic-ai/claude-agent-sdk": "^0.1.30",
    "@slack/bolt": "^3.22.0",
    "@slack/socket-mode": "^2.0.5",
    "@slack/web-api": "^7.5.0",
    "chrono-node": "^2.9.0",
    "claude": ".",
    "dotenv": "^17.2.3",
    "express": "^5.1.0",
    "googleapis": "^133.0.0",
    "mongodb": "^6.9.0",
    "pdf-parse": "^1.1.1",
    "playwright": "^1.56.1",
    "valyu-js": "^2.1.2",
    "zod": "^3.23.8"
  },
  "name": "claude",
  "main": "src/main.ts",
  "type": "module",
  "private": true,
  "devDependencies": {
    "@types/bun": "latest",
    "@types/express": "^5.0.5",
    "@types/pdf-parse": "^1.1.3"
  },
  "scripts": {
    "dev": "bun src/main.ts",
    "start": "bun src/server.ts",
    "slack": "bun src/slackServer.ts"
  },
  "peerDependencies": {
    "typescript": "^5"
  }
}

Main Source Code:

export async function startSlackBotServer(): Promise<void> {
  const appToken = process.env.SLACK_APP_TOKEN;
  const botToken = process.env.SLACK_BOT_TOKEN;

  if (!appToken || !botToken) {
    throw new Error(
      "Missing Slack credentials. Set SLACK_APP_TOKEN and SLACK_BOT_TOKEN.",
    );
  }

  // Create SocketModeReceiver to use latest @slack/socket-mode package
  // This ensures we use the latest version (2.0.5+) instead of the older bundled version
  const socketModeReceiver = new SocketModeReceiver({
    appToken,
  });

  const slackApp = new App({
    token: botToken,
    receiver: socketModeReceiver,
    logLevel: LogLevel.INFO,
    clientOptions: {
      retryConfig: {
        retries: 10,
        factor: 1.96,
        randomize: true,
      },
    },
  });

  slackBotToken = botToken;

  registerEventHandlers(slackApp);

  await slackApp.start();
  setupSocketModeResilience(slackApp);
  console.log(
    `Slack bot started in Socket Mode and is now connected to Slack!`,
  );
}

function registerEventHandlers(slackApp: App): void {
  slackApp.event(
    "app_mention",
    async (
      args: SlackEventMiddlewareArgs<"app_mention"> & AllMiddlewareArgs,
    ) => {
      const { event, client, context, logger } = args;
      const text = cleanSlackText(event.text, context.botUserId);
      const files = extractFileMetadata(event.files);

      if (!text && files.length === 0) {
        return;
      }

      const threadTs = event.thread_ts ?? event.ts;
      const conversation = await getOrCreateConversation(threadTs, event.channel);

      const historyEntry: SlackHistoryEntry = {
        role: "user",
        text,
        ts: event.ts,
        userId: event.user,
        files: files.length ? files : undefined,
      };
      pushHistory(conversation, historyEntry);

      await handleAttachments(historyEntry, conversation, files, logger);

      await maybeScheduleReminder({
        rawText: event.text,
        cleanedText: text,
        channel: event.channel,
        threadTs,
        userId: event.user,
        client,
        logger,
      });

      logger.info(`Slack mention received in #${conversation.channel}`);
      await persistConversation(conversation, logger);
      triggerAssistantResponse(conversation, client, logger).catch((error) => {
        logger.error(error, "Failed processing Slack mention");
      });
    },
  );

  slackApp.event(
    "message",
    async (args: SlackEventMiddlewareArgs<"message"> & AllMiddlewareArgs) => {
      const { event, client, logger, context } = args;
      if (!isUserThreadMessage(event)) {
        return;
      }

      // Only respond to messages in threads that are actively in memory
      // (i.e., threads where the bot was recently @mentioned)
      // Do NOT load old conversations from MongoDB to avoid responding in inactive threads
      const conversation = getConversation(event.thread_ts);
      if (!conversation) {
        return;
      }

      const cleanedText = cleanSlackText(event.text, context.botUserId);
      const files = extractFileMetadata(event.files);
      if (!cleanedText && files.length === 0) {
        return;
      }

      const historyEntry: SlackHistoryEntry = {
        role: "user",
        text: cleanedText,
        ts: event.ts,
        userId: event.user,
        files: files.length ? files : undefined,
      };
      pushHistory(conversation, historyEntry);

      await handleAttachments(historyEntry, conversation, files, logger);

      await maybeScheduleReminder({
        rawText: event.text,
        cleanedText,
        channel: event.channel,
        threadTs: event.thread_ts,
        userId: event.user,
        client,
        logger,
      });

      logger.debug?.(
        `Thread message received for ${conversation.threadTs}; scheduling response`,
      );
      await persistConversation(conversation, logger);
      triggerAssistantResponse(conversation, client, logger).catch((error) => {
        logger.error(error, "Failed processing Slack thread reply");
      });
    },
  );
}
function setupSocketModeResilience(slackApp: App): void {
  const rawClient = (slackApp as unknown as {
    socketModeClient?: {
      on?: (event: string, handler: (...args: unknown[]) => void) => void;
      stateMachine?: {
        config?: {
          global?: {
            unhandledEventHooks?: Array<
              (event: string, state: string) => void
            >;
          };
        };
      };
    };
  }).socketModeClient;

  if (!rawClient || handledSocketClients.has(rawClient)) {
    return;
  }
  handledSocketClients.add(rawClient);

  const globalConfig = rawClient.stateMachine?.config?.global;
  if (globalConfig) {
    globalConfig.unhandledEventHooks =
      globalConfig.unhandledEventHooks ?? [];
    globalConfig.unhandledEventHooks.push((event: string, state: string) => {
      if (event === "server explicit disconnect") {
        console.warn(
          `Slack socket issued "${event}" while ${state}; suppressing crash and waiting for auto-reconnect.`,
        );
      }
    });
  }

  rawClient.on?.("connecting", () => {
    console.log("[Socket Mode] Establishing connection to Slack...");
  });

  rawClient.on?.("connected", () => {
    console.log("[Socket Mode] Successfully connected to Slack!");
  });

  rawClient.on?.("disconnecting", () => {
    console.log("[Socket Mode] Disconnecting from Slack...");
  });

  rawClient.on?.("reconnecting", () => {
    console.log(
      "[Socket Mode] Connection lost. Attempting to reconnect to Slack...",
    );
  });

  rawClient.on?.("disconnected", (error: unknown) => {
    if (error) {
      console.error("[Socket Mode] Disconnected with error:", error);
    } else {
      console.log("[Socket Mode] Gracefully disconnected from Slack.");
    }
  });

  rawClient.on?.("server explicit disconnect", () => {
    console.warn(
      "[Socket Mode] Server explicitly disconnected. Will auto-reconnect.",
    );
  });

  rawClient.on?.("error", (error: unknown) => {
    const errorObj = error as {
      code?: string;
      message?: string;
      data?: { error?: string; response_metadata?: { messages?: string[] } };
    };

    if (errorObj.code === "slack_webapi_platform_error") {
      const slackError = errorObj.data?.error;
      if (slackError === "ratelimited" || slackError === "rate_limited") {
        console.warn(
          "[Socket Mode] Rate limited by Slack API. The client will automatically retry with backoff.",
        );
        return;
      }
    }

    console.error("[Socket Mode] Error:", error);
  });
}