@openclaw/discord 2026.3.13 → 2026.5.1-beta.1

package/src/internal/gateway-close-codes.ts

@@ -0,0 +1,25 @@
+import { GatewayCloseCodes } from "discord-api-types/v10";
+
+const fatalGatewayCloseCodes = new Set<GatewayCloseCodes>([
+  GatewayCloseCodes.AuthenticationFailed,
+  GatewayCloseCodes.InvalidShard,
+  GatewayCloseCodes.ShardingRequired,
+  GatewayCloseCodes.InvalidAPIVersion,
+  GatewayCloseCodes.InvalidIntents,
+  GatewayCloseCodes.DisallowedIntents,
+]);
+
+const nonResumableGatewayCloseCodes = new Set<GatewayCloseCodes>([
+  GatewayCloseCodes.NotAuthenticated,
+  GatewayCloseCodes.InvalidSeq,
+  GatewayCloseCodes.SessionTimedOut,
+  GatewayCloseCodes.AlreadyAuthenticated,
+]);
+
+export function isFatalGatewayCloseCode(code: GatewayCloseCodes): boolean {
+  return fatalGatewayCloseCodes.has(code);
+}
+
+export function canResumeAfterGatewayClose(code: GatewayCloseCodes): boolean {
+  return !nonResumableGatewayCloseCodes.has(code);
+}

package/src/internal/gateway-dispatch.ts

@@ -0,0 +1,96 @@
+import { GatewayDispatchEvents, type APIMessage, type APIUser } from "discord-api-types/v10";
+import type { Client } from "./client.js";
+import { Guild, Message, User } from "./structures.js";
+
+type VoicePluginAdapter = {
+  onVoiceServerUpdate?: (data: unknown) => void;
+  onVoiceStateUpdate?: (data: unknown) => void;
+};
+
+export function dispatchVoiceGatewayEvent(client: Client, type: string, data: unknown): void {
+  const guildId = readGuildId(data);
+  if (!guildId) {
+    return;
+  }
+  const adapters = client.getPlugin<{ adapters?: Map<string, VoicePluginAdapter> }>(
+    "voice",
+  )?.adapters;
+  const adapter = adapters?.get(guildId);
+  const voiceServerUpdate: string = GatewayDispatchEvents.VoiceServerUpdate;
+  const voiceStateUpdate: string = GatewayDispatchEvents.VoiceStateUpdate;
+  if (type === voiceServerUpdate) {
+    adapter?.onVoiceServerUpdate?.(data);
+  }
+  if (type === voiceStateUpdate) {
+    adapter?.onVoiceStateUpdate?.(data);
+  }
+}
+
+export function mapGatewayDispatchData(client: Client, type: string, data: unknown): unknown {
+  const messageCreate: string = GatewayDispatchEvents.MessageCreate;
+  const reactionAdd: string = GatewayDispatchEvents.MessageReactionAdd;
+  const reactionRemove: string = GatewayDispatchEvents.MessageReactionRemove;
+  if (type === messageCreate) {
+    return createMessageDispatchData(client, data as MessageCreatePayload);
+  }
+  if (type === reactionAdd || type === reactionRemove) {
+    return createReactionDispatchData(client, data as ReactionPayload);
+  }
+  return data;
+}
+
+type MessageCreatePayload = {
+  id: string;
+  channel_id: string;
+  guild_id?: string;
+  author?: APIUser;
+  member?: { roles?: string[] };
+};
+
+function createMessageDispatchData(client: Client, data: MessageCreatePayload) {
+  const message = new Message(client, data as APIMessage);
+  return {
+    ...data,
+    id: data.id,
+    channel_id: data.channel_id,
+    channelId: data.channel_id,
+    message,
+    author: message.author ?? (data.author ? new User(client, data.author) : null),
+    member: data.member,
+    rawMember: data.member,
+    guild: data.guild_id ? new Guild<true>(client, data.guild_id) : null,
+  };
+}
+
+type ReactionPayload = {
+  user_id: string;
+  channel_id: string;
+  message_id: string;
+  guild_id?: string;
+  member?: { user?: unknown; roles?: string[] };
+};
+
+function createReactionDispatchData(client: Client, data: ReactionPayload) {
+  const userRaw =
+    data.member?.user && typeof data.member.user === "object"
+      ? ({ id: data.user_id, username: "", ...data.member.user } as APIUser)
+      : ({ id: data.user_id, username: "" } as APIUser);
+  return {
+    ...data,
+    user: new User(client, userRaw),
+    rawMember: data.member,
+    guild: data.guild_id ? new Guild<true>(client, data.guild_id) : null,
+    message: new Message<true>(client, {
+      id: data.message_id,
+      channelId: data.channel_id,
+    }),
+  };
+}
+
+function readGuildId(data: unknown): string | undefined {
+  return data &&
+    typeof data === "object" &&
+    typeof (data as { guild_id?: unknown }).guild_id === "string"
+    ? (data as { guild_id: string }).guild_id
+    : undefined;
+}

package/src/internal/gateway-identify-limiter.ts

@@ -0,0 +1,26 @@
+const IDENTIFY_WINDOW_MS = 5_000;
+
+class GatewayIdentifyLimiter {
+  private nextAllowedAtByKey = new Map<number, number>();
+
+  async wait(params: { shardId?: number; maxConcurrency?: number }): Promise<void> {
+    const maxConcurrency = Math.max(1, Math.floor(params.maxConcurrency ?? 1));
+    const rateKey = (params.shardId ?? 0) % maxConcurrency;
+    const now = Date.now();
+    const nextAllowedAt = this.nextAllowedAtByKey.get(rateKey) ?? now;
+    const waitMs = Math.max(0, nextAllowedAt - now);
+    this.nextAllowedAtByKey.set(rateKey, Math.max(now, nextAllowedAt) + IDENTIFY_WINDOW_MS);
+    if (waitMs > 0) {
+      await new Promise<void>((resolve) => {
+        const timer = setTimeout(resolve, waitMs);
+        timer.unref?.();
+      });
+    }
+  }
+
+  reset(): void {
+    this.nextAllowedAtByKey.clear();
+  }
+}
+
+export const sharedGatewayIdentifyLimiter = new GatewayIdentifyLimiter();

package/src/internal/gateway-lifecycle.ts

@@ -0,0 +1,61 @@
+type GatewayTimer = NodeJS.Timeout;
+
+export class GatewayHeartbeatTimers {
+  heartbeatInterval?: GatewayTimer;
+  firstHeartbeatTimeout?: GatewayTimer;
+
+  start(params: {
+    intervalMs: number;
+    isAcked: () => boolean;
+    onAckTimeout: () => void;
+    onHeartbeat: () => void;
+    random?: () => number;
+  }): void {
+    this.stop();
+    const random = params.random ?? Math.random;
+    this.firstHeartbeatTimeout = setTimeout(
+      params.onHeartbeat,
+      Math.max(0, params.intervalMs * random()),
+    );
+    this.firstHeartbeatTimeout.unref?.();
+    this.heartbeatInterval = setInterval(() => {
+      if (!params.isAcked()) {
+        params.onAckTimeout();
+        return;
+      }
+      params.onHeartbeat();
+    }, params.intervalMs);
+    this.heartbeatInterval.unref?.();
+  }
+
+  stop(): void {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = undefined;
+    }
+    if (this.firstHeartbeatTimeout) {
+      clearTimeout(this.firstHeartbeatTimeout);
+      this.firstHeartbeatTimeout = undefined;
+    }
+  }
+}
+
+export class GatewayReconnectTimer {
+  timeout?: GatewayTimer;
+
+  stop(): void {
+    if (this.timeout) {
+      clearTimeout(this.timeout);
+      this.timeout = undefined;
+    }
+  }
+
+  schedule(delayMs: number, callback: () => void): void {
+    this.stop();
+    this.timeout = setTimeout(() => {
+      this.timeout = undefined;
+      callback();
+    }, delayMs);
+    this.timeout.unref?.();
+  }
+}

package/src/internal/gateway-rate-limit.ts

@@ -0,0 +1,104 @@
+const GATEWAY_SEND_LIMIT = 120;
+const GATEWAY_SEND_WINDOW_MS = 60_000;
+
+type QueuedGatewaySend = {
+  payload: string;
+};
+
+export class GatewaySendLimiter {
+  private outboundSendTimestamps: number[] = [];
+  private outboundQueue: QueuedGatewaySend[] = [];
+  private outboundFlushTimer?: NodeJS.Timeout;
+
+  constructor(
+    private sendNow: (payload: string) => void,
+    private emitError: (error: Error) => void,
+  ) {}
+
+  send(serialized: string, options?: { critical?: boolean }): void {
+    if (options?.critical || this.canSend(Date.now())) {
+      this.sendSerialized(serialized);
+      return;
+    }
+    this.outboundQueue.push({ payload: serialized });
+    this.scheduleFlush();
+  }
+
+  clear(): void {
+    if (this.outboundFlushTimer) {
+      clearTimeout(this.outboundFlushTimer);
+      this.outboundFlushTimer = undefined;
+    }
+    this.outboundQueue = [];
+  }
+
+  getStatus() {
+    const now = Date.now();
+    this.pruneWindow(now);
+    const oldest = this.outboundSendTimestamps[0] ?? now;
+    return {
+      remainingEvents: Math.max(0, GATEWAY_SEND_LIMIT - this.outboundSendTimestamps.length),
+      resetTime:
+        this.outboundSendTimestamps.length > 0
+          ? oldest + GATEWAY_SEND_WINDOW_MS
+          : now + GATEWAY_SEND_WINDOW_MS,
+      currentEventCount: this.outboundSendTimestamps.length,
+      queuedEvents: this.outboundQueue.length,
+    };
+  }
+
+  private pruneWindow(now: number): void {
+    const windowStart = now - GATEWAY_SEND_WINDOW_MS;
+    while (
+      this.outboundSendTimestamps.length > 0 &&
+      (this.outboundSendTimestamps[0] ?? 0) <= windowStart
+    ) {
+      this.outboundSendTimestamps.shift();
+    }
+  }
+
+  private canSend(now: number): boolean {
+    this.pruneWindow(now);
+    return this.outboundSendTimestamps.length < GATEWAY_SEND_LIMIT;
+  }
+
+  private sendSerialized(serialized: string): void {
+    this.outboundSendTimestamps.push(Date.now());
+    this.sendNow(serialized);
+  }
+
+  private scheduleFlush(): void {
+    if (this.outboundFlushTimer || this.outboundQueue.length === 0) {
+      return;
+    }
+    const now = Date.now();
+    this.pruneWindow(now);
+    const oldest = this.outboundSendTimestamps[0] ?? now;
+    const delayMs =
+      this.outboundSendTimestamps.length >= GATEWAY_SEND_LIMIT
+        ? Math.max(0, oldest + GATEWAY_SEND_WINDOW_MS - now)
+        : 0;
+    this.outboundFlushTimer = setTimeout(() => {
+      this.outboundFlushTimer = undefined;
+      this.flush();
+    }, delayMs);
+    this.outboundFlushTimer.unref?.();
+  }
+
+  private flush(): void {
+    while (this.outboundQueue.length > 0 && this.canSend(Date.now())) {
+      const queued = this.outboundQueue.shift();
+      if (!queued) {
+        continue;
+      }
+      try {
+        this.sendSerialized(queued.payload);
+      } catch (error) {
+        this.emitError(error instanceof Error ? error : new Error(String(error), { cause: error }));
+        this.clear();
+        return;
+      }
+    }
+    this.scheduleFlush();
+  }
+}