@openclaw/discord 2026.3.13 → 2026.5.2-beta.1

package/src/internal/rest-body.ts

@@ -0,0 +1,115 @@
+type RequestData = {
+  body?: unknown;
+  multipartStyle?: "message" | "form";
+  rawBody?: boolean;
+  headers?: Record<string, string>;
+};
+
+export function serializeRequestBody(
+  data: RequestData | undefined,
+  headers: Headers,
+): BodyInit | undefined {
+  if (data?.headers) {
+    for (const [key, value] of Object.entries(data.headers)) {
+      headers.set(key, value);
+    }
+  }
+  if (data?.body == null) {
+    return undefined;
+  }
+  if (typeof data.body === "object") {
+    const bodyObject = data.body as Record<string, unknown>;
+    const topLevelFiles = Array.isArray(bodyObject.files) ? bodyObject.files : undefined;
+    const nestedData =
+      bodyObject.data && typeof bodyObject.data === "object"
+        ? (bodyObject.data as Record<string, unknown>)
+        : undefined;
+    const nestedFiles =
+      nestedData && Array.isArray(nestedData.files) ? nestedData.files : undefined;
+    const files = topLevelFiles ?? nestedFiles;
+    const filesContainer = topLevelFiles ? bodyObject : nestedFiles ? nestedData : undefined;
+    if (files?.length && filesContainer) {
+      if (data.multipartStyle === "form") {
+        const formData = new FormData();
+        for (const [key, value] of Object.entries(filesContainer)) {
+          if (key === "files" || value === undefined || value === null) {
+            continue;
+          }
+          formData.append(key, typeof value === "string" ? value : JSON.stringify(value));
+        }
+        for (const file of files) {
+          const item = file as {
+            fieldName?: unknown;
+            name?: unknown;
+            data?: unknown;
+            contentType?: unknown;
+          };
+          const name = typeof item.name === "string" && item.name ? item.name : "file";
+          const blob =
+            item.data instanceof Blob
+              ? item.data
+              : new Blob([item.data as BlobPart], {
+                  type: typeof item.contentType === "string" ? item.contentType : undefined,
+                });
+          formData.append(
+            typeof item.fieldName === "string" && item.fieldName ? item.fieldName : "file",
+            blob,
+            name,
+          );
+        }
+        return formData;
+      }
+      const payloadJson = topLevelFiles
+        ? { ...bodyObject }
+        : { ...bodyObject, data: { ...nestedData } };
+      const payloadFilesContainer = topLevelFiles
+        ? (payloadJson as Record<string, unknown>)
+        : ((payloadJson as { data: Record<string, unknown> }).data ?? {});
+      const formData = new FormData();
+      const existingAttachments = Array.isArray(payloadFilesContainer.attachments)
+        ? [...payloadFilesContainer.attachments]
+        : [];
+      const uploaded = files.map((file, index) => {
+        const item = file as {
+          name?: unknown;
+          data?: unknown;
+          contentType?: unknown;
+          description?: unknown;
+          duration_secs?: unknown;
+          waveform?: unknown;
+        };
+        const name = typeof item.name === "string" && item.name ? item.name : `file-${index}`;
+        const blob =
+          item.data instanceof Blob
+            ? item.data
+            : new Blob([item.data as BlobPart], {
+                type: typeof item.contentType === "string" ? item.contentType : undefined,
+              });
+        const id = existingAttachments.length + index;
+        formData.append(`files[${id}]`, blob, name);
+        const attachment: Record<string, unknown> = {
+          id,
+          filename: name,
+        };
+        if (typeof item.description === "string") {
+          attachment.description = item.description;
+        }
+        if (typeof item.duration_secs === "number") {
+          attachment.duration_secs = item.duration_secs;
+        }
+        if (typeof item.waveform === "string") {
+          attachment.waveform = item.waveform;
+        }
+        return attachment;
+      });
+      payloadFilesContainer.attachments = [...existingAttachments, ...uploaded];
+      delete payloadFilesContainer.files;
+      formData.append("payload_json", JSON.stringify(payloadJson));
+      return formData;
+    }
+  }
+  if (!data.rawBody) {
+    headers.set("Content-Type", "application/json");
+  }
+  return data.rawBody ? (data.body as BodyInit) : JSON.stringify(data.body);
+}

package/src/internal/rest-errors.ts

@@ -0,0 +1,88 @@
+export function readDiscordCode(body: unknown): number | undefined {
+  const value =
+    body && typeof body === "object" && "code" in body
+      ? (body as { code?: unknown }).code
+      : undefined;
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && /^\d+$/.test(value)) {
+    return Number(value);
+  }
+  return undefined;
+}
+
+export function readDiscordMessage(body: unknown, fallback: string): string {
+  const value =
+    body && typeof body === "object" && "message" in body
+      ? (body as { message?: unknown }).message
+      : undefined;
+  return typeof value === "string" && value.trim() ? value : fallback;
+}
+
+function readRetryAfterHeader(value: string | null, now = Date.now()): number | undefined {
+  if (!value) {
+    return undefined;
+  }
+  const seconds = Number(value);
+  if (Number.isFinite(seconds)) {
+    return seconds;
+  }
+  const retryAt = Date.parse(value);
+  return Number.isFinite(retryAt) ? (retryAt - now) / 1000 : undefined;
+}
+
+function coerceRetryAfterSeconds(value: unknown): number | undefined {
+  if (typeof value !== "number" && typeof value !== "string") {
+    return undefined;
+  }
+  const seconds = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(seconds) && seconds >= 0 ? Math.max(0, seconds) : undefined;
+}
+
+export function readRetryAfter(body: unknown, response: Response, fallbackSeconds = 0): number {
+  const bodyValue =
+    body && typeof body === "object" && "retry_after" in body
+      ? (body as { retry_after?: unknown }).retry_after
+      : undefined;
+  return (
+    coerceRetryAfterSeconds(bodyValue) ??
+    coerceRetryAfterSeconds(readRetryAfterHeader(response.headers.get("Retry-After"))) ??
+    fallbackSeconds
+  );
+}
+
+export class DiscordError extends Error {
+  readonly status: number;
+  readonly statusCode: number;
+  readonly rawBody: unknown;
+  readonly rawError: unknown;
+  discordCode?: number;
+
+  constructor(response: Response, body: unknown) {
+    super(readDiscordMessage(body, `Discord API request failed (${response.status})`));
+    this.name = "DiscordError";
+    this.status = response.status;
+    this.statusCode = response.status;
+    this.rawBody = body;
+    this.rawError = body;
+    this.discordCode = readDiscordCode(body);
+  }
+}
+
+export class RateLimitError extends DiscordError {
+  readonly retryAfter: number;
+  readonly scope: string | null;
+  readonly bucket: string | null;
+
+  constructor(
+    response: Response,
+    body: { message: string; retry_after: number; global: boolean; code?: number | string },
+  ) {
+    super(response, body);
+    this.name = "RateLimitError";
+    this.retryAfter = readRetryAfter(body, response, 1);
+    this.scope = body.global ? "global" : response.headers.get("X-RateLimit-Scope");
+    this.bucket = response.headers.get("X-RateLimit-Bucket");
+  }
+}

package/src/internal/rest-routes.ts

@@ -0,0 +1,50 @@
+type QueryValue = string | number | boolean;
+
+export function createRouteKey(method: string, path: string): string {
+  return `${method.toUpperCase()} ${path.split("?")[0] ?? path}`;
+}
+
+function readTopLevelRouteKey(path: string): string {
+  const [pathname = path] = path.split("?");
+  const [first, id, token] = pathname.replace(/^\/+/, "").split("/");
+  if (!first || !id) {
+    return pathname;
+  }
+  if (first === "channels" || first === "guilds" || first === "webhooks") {
+    return first === "webhooks" && token ? `${first}/${id}/${token}` : `${first}/${id}`;
+  }
+  return first;
+}
+
+export function createBucketKey(bucket: string, path: string): string {
+  return `${bucket}:${readTopLevelRouteKey(path)}`;
+}
+
+export function readHeaderNumber(headers: Headers, name: string): number | undefined {
+  const value = headers.get(name);
+  if (!value) {
+    return undefined;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+export function readResetAt(response: Response): number | undefined {
+  const resetAfter = readHeaderNumber(response.headers, "X-RateLimit-Reset-After");
+  if (resetAfter !== undefined) {
+    return Date.now() + Math.max(0, resetAfter * 1000);
+  }
+  const reset = readHeaderNumber(response.headers, "X-RateLimit-Reset");
+  return reset !== undefined ? reset * 1000 : undefined;
+}
+
+export function appendQuery(path: string, query?: Record<string, QueryValue>): string {
+  if (!query || Object.keys(query).length === 0) {
+    return path;
+  }
+  const search = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    search.set(key, String(value));
+  }
+  return `${path}?${search.toString()}`;
+}