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

package/dist/index.d.cts

@@ -138,9 +138,9 @@ interface DiscordProviderConfig {
    */
   waitUntil?: WaitUntilFn;
   /**
-   * Start the Gateway WebSocket (core-owned) so the bot receives DMs, @mentions,
-   * and reactions in addition to slash commands. Set `false` for interactions-
-   * only serverless deployments. Forwarded to the adapter entry as `gateway`.
+   * Start the Gateway WebSocket (provider-owned reconnect loop with backoff)
+   * so the bot receives DMs, @mentions, and reactions in addition to slash
+   * commands. Set `false` for interactions-only serverless deployments.
    *
    * @default true
    */
@@ -308,8 +308,10 @@ interface DiscordInstallation {
  * 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`.)
  */
 declare function resolveDiscordAdapterConfig(config: Pick<DiscordProviderConfig, 'streaming' | 'typingStatus' | 'toolDisplay' | 'gateway'>): {
   streaming: StreamingConfig;
@@ -331,11 +333,15 @@ declare function resolveDiscordAdapterConfig(config: Pick<DiscordProviderConfig,
  * 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
@@ -399,13 +405,8 @@ declare class DiscordProvider implements ChannelProvider {
    */
   activateGuild(webhookId: string, guildId: string): Promise<DiscordInstallation | null>;
   /**
-   * 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.
    */
   disconnect(agentId: string): Promise<void>;
   /**

package/dist/index.d.ts

@@ -138,9 +138,9 @@ interface DiscordProviderConfig {
    */
   waitUntil?: WaitUntilFn;
   /**
-   * Start the Gateway WebSocket (core-owned) so the bot receives DMs, @mentions,
-   * and reactions in addition to slash commands. Set `false` for interactions-
-   * only serverless deployments. Forwarded to the adapter entry as `gateway`.
+   * Start the Gateway WebSocket (provider-owned reconnect loop with backoff)
+   * so the bot receives DMs, @mentions, and reactions in addition to slash
+   * commands. Set `false` for interactions-only serverless deployments.
    *
    * @default true
    */
@@ -308,8 +308,10 @@ interface DiscordInstallation {
  * 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`.)
  */
 declare function resolveDiscordAdapterConfig(config: Pick<DiscordProviderConfig, 'streaming' | 'typingStatus' | 'toolDisplay' | 'gateway'>): {
   streaming: StreamingConfig;
@@ -331,11 +333,15 @@ declare function resolveDiscordAdapterConfig(config: Pick<DiscordProviderConfig,
  * 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
@@ -399,13 +405,8 @@ declare class DiscordProvider implements ChannelProvider {
    */
   activateGuild(webhookId: string, guildId: string): Promise<DiscordInstallation | null>;
   /**
-   * 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.
    */
   disconnect(agentId: string): Promise<void>;
   /**

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/types.ts","../src/discord-provider.ts","../src/install-store.ts","../src/discord-client.ts","../src/commands.ts","../src/crypto.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/types.ts","../src/discord-provider.ts","../src/install-store.ts","../src/discord-client.ts","../src/commands.ts","../src/crypto.ts"],"mappings":"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"}

package/dist/index.js

@@ -300,6 +300,88 @@ function hashCommands(commands) {
 	}));
 	return createHash("sha256").update(JSON.stringify(canonical)).digest("hex").slice(0, 16);
 }
+/**
+* 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;
+/**
+* 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
 /**
@@ -586,8 +668,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 {
@@ -611,11 +695,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
@@ -629,6 +717,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;
@@ -675,6 +772,7 @@ var DiscordProvider = class {
 			this.#storeIsFallback = false;
 		}
 		if (isNewInstance) {
+			this.#stopAllGatewayLoops();
 			this.#adapters.clear();
 			this.#configured = this.#hasSuppliedCredentials();
 		}
@@ -772,6 +870,7 @@ var DiscordProvider = class {
 				app: void 0
 			};
 			this.#configured = false;
+			this.#stopAllGatewayLoops();
 			this.#adapters.clear();
 			this.#initPromise = null;
 			return;
@@ -807,6 +906,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();
@@ -964,19 +1064,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);
 		});
@@ -1110,6 +1206,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));
@@ -1186,13 +1283,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;
@@ -1200,6 +1348,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 } : {}
 		};