@openclaw/discord 2026.5.2 → 2026.5.3-beta.2

package/src/internal/rest.ts

@@ -1,322 +0,0 @@
-import { randomBytes } from "node:crypto";
-import { inspect } from "node:util";
-import { serializeRequestBody } from "./rest-body.js";
-import {
-  DiscordError,
-  RateLimitError,
-  readDiscordCode,
-  readDiscordMessage,
-  readRetryAfter,
-} from "./rest-errors.js";
-import { appendQuery, createRouteKey } from "./rest-routes.js";
-import {
-  RestScheduler,
-  type RequestPriority as RestRequestPriority,
-  type RequestQuery,
-} from "./rest-scheduler.js";
-import { isDiscordRateLimitBody } from "./schemas.js";
-
-export { DiscordError, RateLimitError } from "./rest-errors.js";
-
-export type RuntimeProfile = "serverless" | "persistent";
-export type RequestPriority = RestRequestPriority;
-export type RequestSchedulerOptions = {
-  lanes?: Partial<
-    Record<RequestPriority, { maxQueueSize?: number; staleAfterMs?: number; weight?: number }>
-  >;
-  maxConcurrency?: number;
-  maxRateLimitRetries?: number;
-};
-
-export type RequestClientOptions = {
-  tokenHeader?: "Bot" | "Bearer";
-  baseUrl?: string;
-  apiVersion?: number;
-  userAgent?: string;
-  timeout?: number;
-  queueRequests?: boolean;
-  maxQueueSize?: number;
-  runtimeProfile?: RuntimeProfile;
-  scheduler?: RequestSchedulerOptions;
-  fetch?: (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
-};
-
-export type RequestData = {
-  body?: unknown;
-  multipartStyle?: "message" | "form";
-  rawBody?: boolean;
-  headers?: Record<string, string>;
-};
-
-export type QueuedRequest = {
-  method: string;
-  path: string;
-  data?: RequestData;
-  query?: RequestQuery;
-  resolve: (value?: unknown) => void;
-  reject: (reason?: unknown) => void;
-  routeKey: string;
-};
-
-const defaultOptions = {
-  tokenHeader: "Bot" as const,
-  baseUrl: "https://discord.com/api",
-  apiVersion: 10,
-  userAgent: "OpenClaw Discord",
-  timeout: 15_000,
-  queueRequests: true,
-  maxQueueSize: 1000,
-  runtimeProfile: "persistent" as RuntimeProfile,
-};
-
-const DEFAULT_MAX_CONCURRENT_WORKERS = 4;
-const defaultLaneOptions: Record<RestRequestPriority, { staleAfterMs?: number; weight: number }> = {
-  critical: { weight: 6 },
-  standard: { weight: 3 },
-  background: { staleAfterMs: 20_000, weight: 1 },
-};
-
-function coerceResponseBody(raw: string): unknown {
-  if (!raw) {
-    return undefined;
-  }
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return raw;
-  }
-}
-
-function escapeMultipartQuotedValue(value: string): string {
-  return value.replace(/["\r\n]/g, (ch) => (ch === '"' ? "%22" : ch === "\r" ? "%0D" : "%0A"));
-}
-
-async function formDataToMultipartBody(body: FormData, headers: Headers): Promise<BodyInit> {
-  const boundary = `----openclaw-discord-${randomBytes(12).toString("hex")}`;
-  headers.set("Content-Type", `multipart/form-data; boundary=${boundary}`);
-  const chunks: Buffer[] = [];
-  const push = (value: string | Buffer) => {
-    chunks.push(typeof value === "string" ? Buffer.from(value) : value);
-  };
-  for (const [key, value] of body.entries()) {
-    push(`--${boundary}\r\n`);
-    const escapedKey = escapeMultipartQuotedValue(key);
-    if (typeof value === "string") {
-      push(`Content-Disposition: form-data; name="${escapedKey}"\r\n\r\n`);
-      push(value);
-      push("\r\n");
-      continue;
-    }
-    const filename = (value as Blob & { name?: unknown }).name;
-    const escapedFilename = escapeMultipartQuotedValue(
-      typeof filename === "string" && filename.length > 0 ? filename : "blob",
-    );
-    push(`Content-Disposition: form-data; name="${escapedKey}"; filename="${escapedFilename}"\r\n`);
-    if (value.type) {
-      push(`Content-Type: ${value.type}\r\n`);
-    }
-    push("\r\n");
-    push(Buffer.from(await value.arrayBuffer()));
-    push("\r\n");
-  }
-  push(`--${boundary}--\r\n`);
-  return Buffer.concat(chunks) as unknown as BodyInit;
-}
-
-async function normalizeFetchBody(
-  body: BodyInit | undefined,
-  headers: Headers,
-): Promise<BodyInit | undefined> {
-  if (body instanceof FormData) {
-    return await formDataToMultipartBody(body, headers);
-  }
-  return body;
-}
-
-export class RequestClient {
-  readonly options: RequestClientOptions;
-  protected token: string;
-  protected customFetch: RequestClientOptions["fetch"];
-  protected requestControllers = new Set<AbortController>();
-  private scheduler: RestScheduler<RequestData>;
-
-  constructor(token: string, options?: RequestClientOptions) {
-    this.token = token.replace(/^Bot\s+/i, "");
-    this.customFetch = options?.fetch;
-    this.options = { ...defaultOptions, ...options };
-    this.scheduler = new RestScheduler<RequestData>(
-      {
-        lanes: normalizeSchedulerLanes(
-          this.options.maxQueueSize ?? defaultOptions.maxQueueSize,
-          this.options.scheduler?.lanes,
-        ),
-        maxConcurrency: this.options.scheduler?.maxConcurrency ?? DEFAULT_MAX_CONCURRENT_WORKERS,
-        maxQueueSize: this.options.maxQueueSize ?? defaultOptions.maxQueueSize,
-        maxRateLimitRetries: this.options.scheduler?.maxRateLimitRetries ?? 3,
-      },
-      async (request) =>
-        await this.executeRequest(
-          request.method,
-          request.path,
-          { data: request.data, query: request.query },
-          request.routeKey,
-        ),
-    );
-  }
-
-  async get(path: string, query?: QueuedRequest["query"]): Promise<unknown> {
-    return await this.request("GET", path, { query });
-  }
-
-  async post(path: string, data?: RequestData, query?: QueuedRequest["query"]): Promise<unknown> {
-    return await this.request("POST", path, { data, query });
-  }
-
-  async patch(path: string, data?: RequestData, query?: QueuedRequest["query"]): Promise<unknown> {
-    return await this.request("PATCH", path, { data, query });
-  }
-
-  async put(path: string, data?: RequestData, query?: QueuedRequest["query"]): Promise<unknown> {
-    return await this.request("PUT", path, { data, query });
-  }
-
-  async delete(path: string, data?: RequestData, query?: QueuedRequest["query"]): Promise<unknown> {
-    return await this.request("DELETE", path, { data, query });
-  }
-
-  protected async request(
-    method: string,
-    path: string,
-    params: { data?: RequestData; query?: QueuedRequest["query"] },
-  ): Promise<unknown> {
-    const routeKey = createRouteKey(method, path);
-    if (!this.options.queueRequests) {
-      return await this.executeRequest(method, path, params, routeKey);
-    }
-    return await this.scheduler.enqueue({
-      method,
-      path,
-      priority: getRequestPriority(method, path),
-      ...params,
-    });
-  }
-
-  protected async executeRequest(
-    method: string,
-    path: string,
-    params: { data?: RequestData; query?: QueuedRequest["query"] },
-    routeKey = createRouteKey(method, path),
-  ): Promise<unknown> {
-    const url = `${this.options.baseUrl}/v${this.options.apiVersion}${appendQuery(path, params.query)}`;
-    const headers = new Headers({
-      "User-Agent": this.options.userAgent ?? defaultOptions.userAgent,
-    });
-    if (this.token !== "webhook") {
-      headers.set("Authorization", `${this.options.tokenHeader ?? "Bot"} ${this.token}`);
-    }
-    const body = serializeRequestBody(params.data, headers);
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), this.options.timeout ?? 15_000);
-    timeout.unref?.();
-    this.requestControllers.add(controller);
-    try {
-      const response = await (this.customFetch ?? fetch)(url, {
-        method,
-        headers,
-        body: await normalizeFetchBody(body, headers),
-        signal: controller.signal,
-      });
-      const text = await response.text();
-      const parsed = coerceResponseBody(text);
-      this.scheduler.recordResponse(routeKey, path, response, parsed);
-      if (response.status === 204) {
-        return undefined;
-      }
-      if (response.status === 429) {
-        const rateLimitBody = isDiscordRateLimitBody(parsed) ? parsed : undefined;
-        throw new RateLimitError(response, {
-          message: readDiscordMessage(rateLimitBody, "Rate limited"),
-          retry_after: readRetryAfter(rateLimitBody, response, 1),
-          code: readDiscordCode(rateLimitBody),
-          global: Boolean(rateLimitBody?.global),
-        });
-      }
-      if (!response.ok) {
-        throw new DiscordError(response, parsed);
-      }
-      return parsed;
-    } catch (error) {
-      if (error instanceof DOMException && error.name === "AbortError") {
-        throw error;
-      }
-      if (error instanceof Error) {
-        throw error;
-      }
-      throw new Error(`Discord request failed: ${inspect(error)}`, { cause: error });
-    } finally {
-      clearTimeout(timeout);
-      this.requestControllers.delete(controller);
-    }
-  }
-
-  clearQueue(): void {
-    this.scheduler.clearQueue();
-  }
-
-  get queueSize(): number {
-    return this.scheduler.queueSize;
-  }
-
-  getSchedulerMetrics() {
-    return this.scheduler.getMetrics();
-  }
-
-  abortAllRequests(): void {
-    this.scheduler.abortPending();
-    for (const controller of this.requestControllers) {
-      controller.abort();
-    }
-    this.requestControllers.clear();
-  }
-}
-
-function normalizeSchedulerLanes(
-  maxQueueSize: number,
-  lanes?: RequestSchedulerOptions["lanes"],
-): Record<RestRequestPriority, { maxQueueSize: number; staleAfterMs?: number; weight: number }> {
-  const fallbackMaxQueueSize = Math.max(1, Math.floor(maxQueueSize));
-  return {
-    critical: normalizeSchedulerLane("critical", fallbackMaxQueueSize, lanes?.critical),
-    standard: normalizeSchedulerLane("standard", fallbackMaxQueueSize, lanes?.standard),
-    background: normalizeSchedulerLane("background", fallbackMaxQueueSize, lanes?.background),
-  };
-}
-
-function normalizeSchedulerLane(
-  lane: RestRequestPriority,
-  maxQueueSize: number,
-  options?: { maxQueueSize?: number; staleAfterMs?: number; weight?: number },
-): { maxQueueSize: number; staleAfterMs?: number; weight: number } {
-  const defaults = defaultLaneOptions[lane];
-  return {
-    maxQueueSize:
-      options?.maxQueueSize !== undefined
-        ? Math.max(1, Math.floor(options.maxQueueSize))
-        : maxQueueSize,
-    staleAfterMs:
-      options?.staleAfterMs !== undefined
-        ? Math.max(0, Math.floor(options.staleAfterMs))
-        : defaults.staleAfterMs,
-    weight:
-      options?.weight !== undefined ? Math.max(1, Math.floor(options.weight)) : defaults.weight,
-  };
-}
-
-function getRequestPriority(method: string, path: string): RestRequestPriority {
-  const normalizedMethod = method.toUpperCase();
-  const normalizedPath = path.toLowerCase();
-  if (/^\/interactions\/\d+\/[^/]+\/callback$/.test(normalizedPath)) {
-    return "critical";
-  }
-  return normalizedMethod === "GET" ? "background" : "standard";
-}

package/src/internal/schemas.ts

@@ -1,36 +0,0 @@
-import { Type } from "typebox";
-import { Check } from "typebox/value";
-
-const discordInteractionPayloadSchema = Type.Object(
-  {
-    id: Type.String({ minLength: 1 }),
-    token: Type.String({ minLength: 1 }),
-    type: Type.Number(),
-  },
-  { additionalProperties: true },
-);
-
-const discordRateLimitBodySchema = Type.Object(
-  {
-    message: Type.Optional(Type.String()),
-    retry_after: Type.Optional(Type.Union([Type.Number(), Type.String()])),
-    global: Type.Optional(Type.Boolean()),
-    code: Type.Optional(Type.Union([Type.Number(), Type.String()])),
-  },
-  { additionalProperties: true },
-);
-
-export function assertDiscordInteractionPayload(value: unknown): void {
-  if (!Check(discordInteractionPayloadSchema, value)) {
-    throw new Error("Invalid Discord interaction payload");
-  }
-}
-
-export function isDiscordRateLimitBody(value: unknown): value is {
-  message?: string;
-  retry_after?: number | string;
-  global?: boolean;
-  code?: number | string;
-} {
-  return Check(discordRateLimitBodySchema, value);
-}

package/src/internal/structures.test.ts

@@ -1,43 +0,0 @@
-import { ChannelType } from "discord-api-types/v10";
-import { describe, expect, it } from "vitest";
-import { channelFactory, type StructureClient } from "./structures.js";
-
-const client: StructureClient = {
-  rest: {} as StructureClient["rest"],
-  async fetchUser() {
-    throw new Error("not used");
-  },
-};
-
-describe("channelFactory", () => {
-  it("maps Discord API thread owner and parent fields to camelCase aliases", () => {
-    const channel = channelFactory(client, {
-      id: "thread-1",
-      type: ChannelType.PublicThread,
-      guild_id: "guild-1",
-      name: "support",
-      owner_id: "owner-1",
-      parent_id: "parent-1",
-      last_message_id: null,
-      rate_limit_per_user: 0,
-      thread_metadata: {
-        archived: false,
-        auto_archive_duration: 60,
-        locked: false,
-        archive_timestamp: new Date(0).toISOString(),
-      },
-      message_count: 1,
-      member_count: 1,
-      total_message_sent: 1,
-    });
-
-    expect(channel.parentId).toBe("parent-1");
-    expect(channel.ownerId).toBe("owner-1");
-    expect(
-      channel.rawData && "parent_id" in channel.rawData ? channel.rawData.parent_id : undefined,
-    ).toBe("parent-1");
-    expect(
-      channel.rawData && "owner_id" in channel.rawData ? channel.rawData.owner_id : undefined,
-    ).toBe("owner-1");
-  });
-});

package/src/internal/structures.ts

@@ -1,280 +0,0 @@
-import {
-  type APIChannel,
-  type APIEmbed,
-  type APIGuild,
-  type APIGuildMember,
-  type APIMessage,
-  type APIRole,
-  type APIUser,
-  type MessageType,
-} from "discord-api-types/v10";
-import {
-  createChannelMessage,
-  createUserDmChannel,
-  deleteChannelMessage,
-  editChannelMessage,
-  getChannelMessage,
-  pinChannelMessage,
-  unpinChannelMessage,
-} from "./api.js";
-import { serializePayload, type MessagePayload } from "./payload.js";
-import type { RequestClient } from "./rest.js";
-
-type RawOrId<T> = T | string | { id: string; channelId?: string };
-export type StructureClient = {
-  rest: RequestClient;
-  fetchUser(id: string): Promise<User>;
-};
-
-export class Base {
-  constructor(protected client: StructureClient) {}
-}
-
-export class User<IsPartial extends boolean = false> extends Base {
-  protected _rawData: APIUser | null;
-  readonly id: string;
-
-  constructor(client: StructureClient, rawDataOrId: IsPartial extends true ? string : APIUser) {
-    super(client);
-    this._rawData = typeof rawDataOrId === "string" ? null : rawDataOrId;
-    this.id = typeof rawDataOrId === "string" ? rawDataOrId : rawDataOrId.id;
-  }
-
-  get rawData(): Readonly<APIUser> {
-    if (!this._rawData) {
-      throw new Error("Partial Discord user has no raw data");
-    }
-    return this._rawData;
-  }
-  get partial(): IsPartial {
-    return (this._rawData === null) as IsPartial;
-  }
-  get username() {
-    return this._rawData?.username ?? "";
-  }
-  get globalName() {
-    return this._rawData?.global_name;
-  }
-  get discriminator() {
-    return this._rawData?.discriminator;
-  }
-  get bot() {
-    return this._rawData?.bot;
-  }
-  get avatar() {
-    return this._rawData?.avatar;
-  }
-  get avatarUrl() {
-    return this.avatar ? `https://cdn.discordapp.com/avatars/${this.id}/${this.avatar}.png` : null;
-  }
-  toString(): string {
-    return `<@${this.id}>`;
-  }
-  async fetch(): Promise<User> {
-    return this.client.fetchUser(this.id);
-  }
-  async createDm() {
-    return await createUserDmChannel(this.client.rest, this.id);
-  }
-  async send(data: MessagePayload): Promise<Message> {
-    const dm = await this.createDm();
-    const message = await createChannelMessage(this.client.rest, dm.id, {
-      body: serializePayload(data),
-    });
-    return new Message(this.client, message);
-  }
-}
-
-export class Role<IsPartial extends boolean = false> extends Base {
-  protected _rawData: APIRole | null;
-  readonly id: string;
-  constructor(client: StructureClient, rawDataOrId: IsPartial extends true ? string : APIRole) {
-    super(client);
-    this._rawData = typeof rawDataOrId === "string" ? null : rawDataOrId;
-    this.id = typeof rawDataOrId === "string" ? rawDataOrId : rawDataOrId.id;
-  }
-  get name() {
-    return this._rawData?.name ?? "";
-  }
-}
-
-export class Guild<IsPartial extends boolean = false> extends Base {
-  protected _rawData: APIGuild | null;
-  readonly id: string;
-  constructor(client: StructureClient, rawDataOrId: IsPartial extends true ? string : APIGuild) {
-    super(client);
-    this._rawData = typeof rawDataOrId === "string" ? null : rawDataOrId;
-    this.id = typeof rawDataOrId === "string" ? rawDataOrId : rawDataOrId.id;
-  }
-  get name() {
-    return this._rawData?.name ?? "";
-  }
-}
-
-export class GuildMember extends Base {
-  constructor(
-    client: StructureClient,
-    public rawData: APIGuildMember,
-  ) {
-    super(client);
-  }
-  get user() {
-    return this.rawData.user ? new User(this.client, this.rawData.user) : null;
-  }
-  get roles() {
-    return (this.rawData.roles ?? []) as Array<string | Role>;
-  }
-  get nickname() {
-    return this.rawData.nick ?? undefined;
-  }
-}
-
-export class Message<IsPartial extends boolean = false> extends Base {
-  protected _rawData: APIMessage | null;
-  readonly id: string;
-  readonly channelId: string;
-
-  constructor(client: StructureClient, rawDataOrIds: RawOrId<APIMessage>) {
-    super(client);
-    this._rawData =
-      typeof rawDataOrIds === "string" || !("author" in rawDataOrIds) ? null : rawDataOrIds;
-    this.id = typeof rawDataOrIds === "string" ? rawDataOrIds : rawDataOrIds.id;
-    this.channelId =
-      typeof rawDataOrIds === "string"
-        ? ""
-        : "channel_id" in rawDataOrIds
-          ? rawDataOrIds.channel_id
-          : (rawDataOrIds.channelId ?? "");
-  }
-
-  get rawData(): Readonly<APIMessage> {
-    if (!this._rawData) {
-      throw new Error("Partial Discord message has no raw data");
-    }
-    return this._rawData;
-  }
-  get partial(): IsPartial {
-    return (this._rawData === null) as IsPartial;
-  }
-  get message(): Message<IsPartial> {
-    return this;
-  }
-  get channel_id() {
-    return this.channelId;
-  }
-  get guild_id() {
-    return (this._rawData as { guild_id?: string } | null)?.guild_id;
-  }
-  get guild() {
-    return this.guild_id ? new Guild<true>(this.client, this.guild_id) : null;
-  }
-  get webhookId() {
-    return this.webhook_id;
-  }
-  get webhook_id() {
-    return (this._rawData as { webhook_id?: string | null } | null)?.webhook_id ?? null;
-  }
-  get member() {
-    const member = (this._rawData as { member?: APIGuildMember } | null)?.member;
-    return member ? new GuildMember(this.client, member) : null;
-  }
-  get rawMember() {
-    return (this._rawData as { member?: APIGuildMember } | null)?.member;
-  }
-  get content() {
-    return this._rawData?.content ?? "";
-  }
-  get author() {
-    return this._rawData?.author ? new User(this.client, this._rawData.author) : null;
-  }
-  get embeds(): APIEmbed[] {
-    return this._rawData?.embeds ?? [];
-  }
-  get attachments() {
-    return this._rawData?.attachments ?? [];
-  }
-  get stickers() {
-    return this._rawData?.sticker_items ?? [];
-  }
-  get mentionedUsers() {
-    return (this._rawData?.mentions ?? []).map((user) => new User(this.client, user));
-  }
-  get mentionedRoles() {
-    return this._rawData?.mention_roles ?? [];
-  }
-  get mentionedEveryone() {
-    return this._rawData?.mention_everyone ?? false;
-  }
-  get timestamp() {
-    return this._rawData?.timestamp;
-  }
-  get type(): MessageType | undefined {
-    return this._rawData?.type;
-  }
-  get messageReference() {
-    return this._rawData?.message_reference;
-  }
-  get referencedMessage() {
-    return this._rawData?.referenced_message
-      ? new Message(this.client, this._rawData.referenced_message)
-      : null;
-  }
-  get thread() {
-    return this._rawData?.thread ? channelFactory(this.client, this._rawData.thread) : null;
-  }
-  async fetch(): Promise<Message> {
-    const raw = await getChannelMessage(this.client.rest, this.channelId, this.id);
-    return new Message(this.client, raw);
-  }
-  async delete(): Promise<void> {
-    await deleteChannelMessage(this.client.rest, this.channelId, this.id);
-  }
-  async edit(data: MessagePayload): Promise<Message> {
-    const raw = await editChannelMessage(this.client.rest, this.channelId, this.id, {
-      body: serializePayload(data),
-    });
-    return new Message(this.client, raw);
-  }
-  async reply(data: MessagePayload): Promise<Message> {
-    const raw = await createChannelMessage(this.client.rest, this.channelId, {
-      body: {
-        ...serializePayload(data),
-        message_reference: { message_id: this.id, fail_if_not_exists: false },
-      },
-    });
-    return new Message(this.client, raw);
-  }
-  async pin(): Promise<void> {
-    await pinChannelMessage(this.client.rest, this.channelId, this.id);
-  }
-  async unpin(): Promise<void> {
-    await unpinChannelMessage(this.client.rest, this.channelId, this.id);
-  }
-}
-
-export type DiscordChannel = APIChannel & {
-  rawData?: APIChannel;
-  guildId?: string;
-  guild?: Guild;
-  name?: string;
-  parentId?: string | null;
-  ownerId?: string | null;
-};
-
-export function channelFactory(
-  _client: StructureClient,
-  channelData: APIChannel,
-  _partial?: boolean,
-): DiscordChannel {
-  return {
-    ...channelData,
-    rawData: channelData,
-    guildId: "guild_id" in channelData ? channelData.guild_id : undefined,
-    guild:
-      "guild_id" in channelData && typeof channelData.guild_id === "string"
-        ? new Guild<true>(_client, channelData.guild_id)
-        : undefined,
-    parentId: "parent_id" in channelData ? channelData.parent_id : undefined,
-    ownerId: "owner_id" in channelData ? channelData.owner_id : undefined,
-  } as DiscordChannel;
-}