@mastra/discord 1.3.0-alpha.0 → 1.3.0-alpha.1

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @mastra/discord
 
+## 1.3.0-alpha.1
+
+### Patch Changes
+
+- Fixed a Discord Gateway reconnect storm that could trip Discord's connection abuse limit (>1000 connects in a short window) and get the bot token force-reset. The provider now owns the Gateway reconnection loop: failed connects (invalid token, Message Content privileged intent not enabled) back off exponentially instead of retrying instantly, a revoked token parks reconnection until new credentials arrive, and exactly one loop runs per installation — credential rotations and `disconnect()` now stop the previous loop instead of leaking it. ([#26095](https://github.com/mastra-ai/mastra/pull/26095))
+
+- Updated dependencies [[`97644a7`](https://github.com/mastra-ai/mastra/commit/97644a78cafe8276026509c56a70108075e950b7), [`4cf860a`](https://github.com/mastra-ai/mastra/commit/4cf860a5a550a21fabce43010e6f1c95710e155c), [`dac82ea`](https://github.com/mastra-ai/mastra/commit/dac82eaa324b66acad38d468799fa4e66594107f), [`97644a7`](https://github.com/mastra-ai/mastra/commit/97644a78cafe8276026509c56a70108075e950b7), [`0a37598`](https://github.com/mastra-ai/mastra/commit/0a375986869049865023d765337db427b6e27436), [`018ae9d`](https://github.com/mastra-ai/mastra/commit/018ae9d2f4ebfd3bd6f267d0010171a546cb3abf), [`c498e24`](https://github.com/mastra-ai/mastra/commit/c498e249038d08a2e2fc31eed7ba4ca5e7fa1aa8), [`045d583`](https://github.com/mastra-ai/mastra/commit/045d583852e55d0c1c518d2f5f9c33b48243cf7d)]:
+  - @mastra/core@1.75.0-alpha.7
+
 ## 1.3.0-alpha.0
 
 ### Minor Changes

package/dist/index.cjs

@@ -109038,7 +109038,7 @@ var require_Shard = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const path$2 = require("path");
 	const process$7 = require("process");
 	const { setTimeout: setTimeout$1, clearTimeout: clearTimeout$1 } = require("timers");
-	const { setTimeout: sleep$1 } = require("timers/promises");
+	const { setTimeout: sleep$2 } = require("timers/promises");
 	const { SHARE_ENV } = require("worker_threads");
 	const { DiscordjsError, ErrorCodes } = require_errors();
 	const ShardEvents = require_ShardEvents();
@@ -109226,7 +109226,7 @@ var require_Shard = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		*/
 		async respawn({ delay = 500, timeout = 3e4 } = {}) {
 			this.kill();
-			if (delay > 0) await sleep$1(delay);
+			if (delay > 0) await sleep$2(delay);
 			return this.spawn(timeout);
 		}
 		/**
@@ -109449,7 +109449,7 @@ var require_ShardingManager = /* @__PURE__ */ __commonJSMin(((exports, module) =
 	const fs = require("fs");
 	const path$1 = require("path");
 	const process$6 = require("process");
-	const { setTimeout: sleep } = require("timers/promises");
+	const { setTimeout: sleep$1 } = require("timers/promises");
 	const { Collection } = require_dist$4();
 	const Shard = require_Shard();
 	const { DiscordjsError, DiscordjsTypeError, DiscordjsRangeError, ErrorCodes } = require_errors();
@@ -109613,7 +109613,7 @@ var require_ShardingManager = /* @__PURE__ */ __commonJSMin(((exports, module) =
 				const promises = [];
 				const shard = this.createShard(shardId);
 				promises.push(shard.spawn(timeout));
-				if (delay > 0 && this.shards.size !== this.shardList.length) promises.push(sleep(delay));
+				if (delay > 0 && this.shards.size !== this.shardList.length) promises.push(sleep$1(delay));
 				await Promise.all(promises);
 			}
 			return this.shards;
@@ -109697,7 +109697,7 @@ var require_ShardingManager = /* @__PURE__ */ __commonJSMin(((exports, module) =
 					delay: respawnDelay,
 					timeout
 				})];
-				if (++s < this.shards.size && shardDelay > 0) promises.push(sleep(shardDelay));
+				if (++s < this.shards.size && shardDelay > 0) promises.push(sleep$1(shardDelay));
 				await Promise.all(promises);
 			}
 			return this.shards;
@@ -123635,6 +123635,120 @@ function hashCommands(commands) {
 	return (0, crypto$1.createHash)("sha256").update(JSON.stringify(canonical)).digest("hex").slice(0, 16);
 }
 //#endregion
+//#region src/gateway-loop.ts
+/**
+* Provider-owned Discord Gateway reconnection loop.
+*
+* Core's `AgentChannels` has a built-in gateway loop, but the provider opts out
+* of it (`gateway: false` on the adapter entry) and runs this one instead,
+* because the core loop has two failure modes that combine into a connect
+* storm — severe enough that Discord's abuse tripwire (>1000 connects in a
+* short window) force-resets the bot token:
+*
+* - `@chat-adapter/discord` **swallows `client.login()` errors**: a session
+*   that fails IDENTIFY (invalid/reset token, the MessageContent privileged
+*   intent not enabled on the app) resolves "cleanly" within milliseconds.
+* - The core loop reconnects **immediately** on a clean session end and keeps
+*   **no abort handle**, so a failing session becomes a zero-delay IDENTIFY
+*   loop that nothing can stop, and every credential rotation leaks another
+*   immortal loop still hammering with the stale token.
+*
+* This loop defends against both: a session that ends before
+* {@link HEALTHY_SESSION_MS} is treated as a failed connect and backed off
+* exponentially; a REST token check distinguishes a revoked token (park the
+* loop until `configure()` delivers new credentials and restarts it) from a
+* transient failure (keep backing off); and the `AbortSignal` lets the
+* provider kill the loop on disconnect, credential rotation, or re-attach.
+* This mirrors how `@mastra/telegram` owns its polling loop (`stopPolling()`
+* on reconfigure/disconnect, capped backoff on errors).
+*/
+/** How long each Gateway session runs before a scheduled reconnect. */
+const GATEWAY_SESSION_MS = 1440 * 60 * 1e3;
+/**
+* A session that ends sooner than this is treated as a failed connect. The
+* adapter resolves login failures as if the session ended cleanly, so elapsed
+* time is the only signal that distinguishes "ran fine until the duration
+* elapsed / Discord closed us" from "IDENTIFY was rejected instantly".
+*/
+const HEALTHY_SESSION_MS = 60 * 1e3;
+/** First retry delay after a failed connect; doubles up to {@link MAX_BACKOFF_MS}. */
+const INITIAL_BACKOFF_MS = 5 * 1e3;
+/** Retry delay ceiling. */
+const MAX_BACKOFF_MS = 900 * 1e3;
+/** Pause between healthy sessions — a scheduled rollover, not a failure. */
+const RECONNECT_DELAY_MS = 1e3;
+/** After this many consecutive failed connects, log a diagnostic hint. */
+const SHORT_SESSION_HINT_THRESHOLD = 3;
+/**
+* Run Gateway sessions back-to-back until `signal` aborts or the bot token is
+* confirmed revoked. Resolves when the loop stops; never rejects.
+*/
+async function runGatewayLoop(deps, signal) {
+	const sessionMs = deps.sessionMs ?? 864e5;
+	let backoffMs = INITIAL_BACKOFF_MS;
+	let consecutiveFailures = 0;
+	while (!signal.aborted) {
+		const startedAt = Date.now();
+		try {
+			let settle;
+			let fail;
+			const done = new Promise((resolve, reject) => {
+				settle = resolve;
+				fail = reject;
+			});
+			let sessionDelivered = false;
+			const response = await deps.startSession({ waitUntil: (promise) => {
+				sessionDelivered = true;
+				promise.then(() => settle(), (err) => fail(err));
+			} }, sessionMs, signal);
+			if (!response.ok || !sessionDelivered) throw new Error(`Gateway session refused (status ${response.status})`);
+			await done;
+		} catch (err) {
+			deps.log("error", `Gateway session error: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		if (signal.aborted) return;
+		const elapsedMs = Date.now() - startedAt;
+		if (elapsedMs >= 6e4) {
+			backoffMs = INITIAL_BACKOFF_MS;
+			consecutiveFailures = 0;
+			deps.log("info", "Gateway session ended; reconnecting");
+			await sleep(RECONNECT_DELAY_MS, signal);
+			continue;
+		}
+		consecutiveFailures += 1;
+		let check;
+		try {
+			check = await deps.checkToken();
+		} catch {
+			check = "unreachable";
+		}
+		if (signal.aborted) return;
+		if (check === "invalid") {
+			deps.log("error", "Discord rejected the bot token (401); Gateway reconnection is parked until configure() supplies new credentials. Reset tokens must be rotated in the Discord Developer Portal and updated wherever this provider gets its credentials.");
+			return;
+		}
+		if (consecutiveFailures === 3) deps.log("error", `Gateway sessions keep ending within ${HEALTHY_SESSION_MS / 1e3}s of starting. The token checks out over REST, so the usual cause is a rejected IDENTIFY: enable the "Message Content Intent" (a privileged intent) for this app in the Discord Developer Portal, or set gateway: false for an interactions-only deployment.`);
+		deps.log("warn", `Gateway session ended after ${Math.round(elapsedMs / 1e3)}s; retrying in ${Math.round(backoffMs / 1e3)}s`);
+		await sleep(backoffMs, signal);
+		backoffMs = Math.min(backoffMs * 2, MAX_BACKOFF_MS);
+	}
+}
+/** Abortable sleep: resolves early (never rejects) when the signal fires. */
+function sleep(ms, signal) {
+	if (signal.aborted) return Promise.resolve();
+	return new Promise((resolve) => {
+		const onAbort = () => {
+			clearTimeout(timer);
+			resolve();
+		};
+		const timer = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+//#endregion
 //#region src/crypto.ts
 /**
 * Opt-in AES-256-GCM encryption for the app's bot token at rest, with
@@ -123931,8 +124045,10 @@ function planReconcile(input) {
 * Resolve the per-adapter config the provider applies to the Discord entry in
 * `AgentChannels.adapters`. Discord has native embeds + action-row buttons, so
 * `toolDisplay` defaults to `'cards'` (unlike Telegram's `'text'`); `streaming`
-* post-and-edits the interaction followup; `gateway` (default `true`) makes core
-* own the DM/mention Gateway reconnection loop.
+* post-and-edits the interaction followup; `gateway` (default `true`) makes the
+* **provider** run the DM/mention Gateway reconnection loop. (The adapter entry
+* handed to `AgentChannels` always carries `gateway: false` — core's loop must
+* never start; see `#createAgentChannels`.)
 */
 function resolveDiscordAdapterConfig(config) {
 	return {
@@ -123956,11 +124072,15 @@ function resolveDiscordAdapterConfig(config) {
 * member) or lazily off the first inbound interaction's authoritative `guild_id`
 * (see {@link activateGuild}).
 *
-* **Gateway is core's job.** The mounted interactions route only ever receives
-* HTTP Interactions (PING, slash commands, buttons). DMs / @mentions / reactions
-* arrive over the Gateway WebSocket, whose reconnection loop core owns: setting
-* `gateway: true` (default) on the adapter entry is enough — the wrapper never
-* calls `startGatewayListener` or runs a reconnect loop.
+* **Gateway is the provider's job.** The mounted interactions route only ever
+* receives HTTP Interactions (PING, slash commands, buttons). DMs / @mentions /
+* reactions arrive over the Gateway WebSocket, whose reconnection loop the
+* provider owns ({@link #startGatewayLoop} → `./gateway-loop`): one abortable
+* loop per installation, exponential backoff on failed connects, parked on a
+* revoked token. Core's `AgentChannels` loop is explicitly disabled
+* (`gateway: false` on the adapter entry) — it reconnects with no backoff and
+* cannot be stopped, which is how a failing IDENTIFY once tripped Discord's
+* 1000-connect abuse limit and got the bot token force-reset.
 *
 * Implemented (issues `mastra-discord-13x.2` + `.3`): the app-config +
 * guild-keyed install store, `connect()`/`disconnect()`, OAuth2 invite-URL
@@ -123974,6 +124094,15 @@ var DiscordProvider = class {
 	#store;
 	/** Live adapters, keyed by installation id (one per agent; all share the app's bot token). */
 	#adapters = /* @__PURE__ */ new Map();
+	/**
+	* Live Gateway reconnect loops, keyed by installation id. Aborting a
+	* controller ends the loop and destroys its discord.js client. Exactly one
+	* loop may exist per installation — {@link #startGatewayLoop} aborts any
+	* predecessor, so credential rotations and adapter rebuilds can't leak loops
+	* that keep IDENTIFYing with stale tokens (Discord force-resets the bot
+	* token past ~1000 connects in a short window).
+	*/
+	#gatewayLoops = /* @__PURE__ */ new Map();
 	/** Cached sync view of whether the app is configured (for {@link getInfo}). */
 	#configured = false;
 	#initPromise = null;
@@ -124020,6 +124149,7 @@ var DiscordProvider = class {
 			this.#storeIsFallback = false;
 		}
 		if (isNewInstance) {
+			this.#stopAllGatewayLoops();
 			this.#adapters.clear();
 			this.#configured = this.#hasSuppliedCredentials();
 		}
@@ -124117,6 +124247,7 @@ var DiscordProvider = class {
 				app: void 0
 			};
 			this.#configured = false;
+			this.#stopAllGatewayLoops();
 			this.#adapters.clear();
 			this.#initPromise = null;
 			return;
@@ -124152,6 +124283,7 @@ var DiscordProvider = class {
 			if (merged.botToken && merged.publicKey && merged.applicationId) await store.saveAppConfig(merged);
 		}
 		const wasInitialized = this.#initPromise !== null;
+		this.#stopAllGatewayLoops();
 		this.#adapters.clear();
 		this.#initPromise = null;
 		if (wasInitialized) await this.initialize();
@@ -124309,19 +124441,15 @@ var DiscordProvider = class {
 		return installation;
 	}
 	/**
-	* Disconnect an agent from Discord: remove its installation row and drop the
-	* adapter entry.
-	*
-	* **Limitation:** the Gateway loop is owned by core (it calls
-	* `startGatewayListener` itself; there is no `stopGatewayListener`), so
-	* disconnect cannot kill an in-flight gateway window — it lapses at the next
-	* duration boundary. Contrast Telegram's clean `stopPolling()`.
+	* Disconnect an agent from Discord: abort its Gateway loop, remove its
+	* installation row, and drop the adapter entry.
 	*/
 	async disconnect(agentId) {
 		const store = await this.#getStore();
 		const existing = await store.getByAgent(agentId);
 		if (!existing) throw new Error(`No Discord installation found for agent "${agentId}"`);
 		await this.#enqueueWebhookTask(existing.webhookId, async () => {
+			this.#stopGatewayLoop(existing.id);
 			this.#adapters.delete(existing.id);
 			await store.deleteByAgent(agentId);
 		});
@@ -124455,6 +124583,7 @@ var DiscordProvider = class {
 		if (!channels || channels.adapters["discord"] !== adapter) {
 			channels = this.#createAgentChannels(agent, adapter);
 			await channels.initialize(this.#mastra);
+			this.#startGatewayLoop(installation, adapter, app);
 		}
 		try {
 			return scheduleActivation(await channels.handleWebhookEvent(PLATFORM, c.req.raw, waitUntil ? { waitUntil } : void 0));
@@ -124531,13 +124660,64 @@ var DiscordProvider = class {
 		if (!app) return;
 		const agent = this.#resolveAgent(installation.agentId);
 		const adapter = this.#getOrCreateAdapter(installation, app);
-		if (agent && this.#mastra) await this.#createAgentChannels(agent, adapter).initialize(this.#mastra);
+		if (agent && this.#mastra) {
+			await this.#createAgentChannels(agent, adapter).initialize(this.#mastra);
+			this.#startGatewayLoop(installation, adapter, app);
+		}
+	}
+	/**
+	* Start (or restart) the Gateway reconnect loop for an installation. Any
+	* previous loop for the same installation is aborted first, so adapter
+	* rebuilds and credential rotations replace the loop instead of stacking
+	* another one. No-op when the provider is configured `gateway: false`.
+	*
+	* The loop itself lives in {@link runGatewayLoop}; see that module for why
+	* the provider owns this instead of core's `AgentChannels` loop.
+	*/
+	#startGatewayLoop(installation, adapter, app) {
+		if (!resolveDiscordAdapterConfig(this.#config).gateway) return;
+		this.#stopGatewayLoop(installation.id);
+		const controller = new AbortController();
+		this.#gatewayLoops.set(installation.id, controller);
+		const apiBaseUrl = this.#apiBaseUrl();
+		runGatewayLoop({
+			startSession: (options, durationMs, signal) => adapter.startGatewayListener(options, durationMs, signal),
+			checkToken: async () => {
+				try {
+					const response = await discordRequest(app.botToken, "GET", "/applications/@me", apiBaseUrl);
+					return response.status === 401 ? "invalid" : response.ok ? "valid" : "unreachable";
+				} catch {
+					return "unreachable";
+				}
+			},
+			log: (level, message) => {
+				const line = `[Discord] [gateway:${installation.agentId}] ${message}`;
+				if (level === "error") console.error(line);
+				else if (level === "warn") console.warn(line);
+				else console.info(line);
+			}
+		}, controller.signal).finally(() => {
+			if (this.#gatewayLoops.get(installation.id) === controller) this.#gatewayLoops.delete(installation.id);
+		});
+	}
+	/** Abort an installation's Gateway loop (ends the session, destroys the client). */
+	#stopGatewayLoop(installationId) {
+		const controller = this.#gatewayLoops.get(installationId);
+		if (!controller) return;
+		this.#gatewayLoops.delete(installationId);
+		controller.abort();
+	}
+	/** Abort every Gateway loop — credential revocation or Mastra re-attach. */
+	#stopAllGatewayLoops() {
+		for (const installationId of [...this.#gatewayLoops.keys()]) this.#stopGatewayLoop(installationId);
 	}
 	/**
 	* Create AgentChannels for an agent with the Discord adapter, preserving any
 	* adapters/config the agent author already configured (mirrors `@mastra/slack`
-	* / `@mastra/telegram`). `gateway: true` (default) makes core start the Gateway
-	* reconnection loop for DMs/mentions.
+	* / `@mastra/telegram`). The entry always carries `gateway: false`: core's
+	* built-in gateway loop reconnects with no backoff and no abort handle, so
+	* the provider owns the Gateway lifecycle instead ({@link #startGatewayLoop},
+	* gated on the provider-level `gateway` config).
 	*/
 	#createAgentChannels(agent, adapter) {
 		const existingConfig = agent.getChannels()?.channelConfig;
@@ -124545,6 +124725,7 @@ var DiscordProvider = class {
 		const entry = {
 			adapter,
 			...resolveDiscordAdapterConfig(cfg),
+			gateway: false,
 			...cfg.cors !== void 0 ? { cors: cfg.cors } : {},
 			...cfg.formatError !== void 0 ? { formatError: cfg.formatError } : {}
 		};