kodiakhq · Oct 17, 2026 · Oct 17, 2026 · coldtea-pr-lens · Oct 17, 2026
@@ -0,0 +1,5 @@
+---
+"@wolfstar/plugin-gateway": minor
+---
+
+Check the options of `threads.create` and the guild-only message paths against discord.js. `ThreadCreateOptions` is now `TextThreadCreateOptions | ForumThreadCreateOptions`, so mixing the options of a thread (`type`, `invitable`) with those of a forum or media post (`message`, `appliedTags`) is a compile error, and throws a `GatewayTypeError` before any request instead of being dropped silently: `ThreadOptionsPostOnly`, `ThreadOptionsThreadOnly`, and, in a forum or media channel without `message`, `ThreadPostMessageRequired`. `ChannelThreadManager` and `ChannelMessageManager` take the channel type as an optional last constructor argument (`channelType`), which `channel.threads` and `channel.messages` pass. In a direct message or group direct message, `messages.crosspost`, `messages.bulkDelete`, and `messages.startThread` now throw `ChannelMessagesGuildOnly` before any request, as discord.js's `DMMessageManager` has no such methods.
@@ -981,6 +981,16 @@ const post = await forum.threads.create({
 });
 ```
 
+discord.js has a manager per kind of channel (`GuildTextThreadManager`, `GuildForumThreadManager`); here
+`threads` is one `ChannelThreadManager`, and `create` takes either the options of a thread (`type`,
+`invitable`) or those of a forum or media post (`message`, `appliedTags`), told apart by `message`. Mixing
+them is a compile error, and throws a `GatewayTypeError` before any request: `ThreadOptionsPostOnly`
+(`appliedTags` without `message`, or `message` in a text or announcement channel),
+`ThreadOptionsThreadOnly` (`type` or `invitable` with `message`), and `ThreadPostMessageRequired` (a
+forum or media channel without `message`). `autoArchiveDuration` and `rateLimitPerUser` apply to both. Unlike
+discord.js, a thread started from a message is `message.startThread()`, not an option, and an explicit `type`
+is not overridden in an announcement channel.
+
 ### Voice states and presences
 
 `client.voiceStates` and `client.presences` read the voice states and presences the gateway sends
@@ -1200,6 +1210,14 @@ discord.js) also get `bulkDelete`, which takes messages, their IDs, a `Collectio
 resolves to a `Collection` of the deleted messages by ID: the cached `Message`, else a partial one
 with `Partials.Message`, else `undefined`. Narrow a `Message | PartialMessage` with `partial`.
 
+`channel.messages` is one `ChannelMessageManager` for every kind of channel, where discord.js has
+`GuildMessageManager`, `DMMessageManager`, and `PartialGroupDMMessageManager`. Its guild-only methods
+(`crosspost`, `bulkDelete`, `startThread`) throw `ChannelMessagesGuildOnly` before any request in a direct
+message or group direct message; the rest (`fetch`, `send`, `edit`, `delete`, `pin`, `react`, ...) is the
+same everywhere. `crosspost` takes a message ID, not a `MessageResolvable`, like the other methods of the
+manager. discord.js's `client.channels.createMessage(channel, options)` is `client.messages.send(channelId,
+options)` (or `channel.send(options)`) here.
+
 `Message` is generic like discord.js's: `Message<true>` has a `guildId` string and guild-text-based `channel`s, and
 `inGuild()` narrows to it. `reply`, `edit`, and the other actions resolve to messages whose `channel` is never a group
 DM (`OmitPartialGroupDMChannel`), `fetch(force)` answers from the cache when `force` is `false`, `forward` takes a

@@ -60,6 +60,11 @@ export const GatewayErrorMessages = {
   GuildResolve: "Cannot resolve the value to a guild ID",
   GuildRoleUnknown: (guildId: string, roleId: string) =>
     `Role ${roleId} is not a role of guild ${guildId}`,
+  ThreadPostMessageRequired: "A forum or media post needs a first message: pass message",
+  ThreadOptionsPostOnly: (options: string) => `Only a forum or media post takes ${options}`,
+  ThreadOptionsThreadOnly: (options: string) => `Only a thread without a message takes ${options}`,
+  ChannelMessagesGuildOnly: (channelId: string, action: string) =>
+    `${action} is only available in guild channels, and channel ${channelId} is a direct message`,
   ThreadParentUnknown: (threadId: string) => `Thread ${threadId} has no known parent`,
   ThreadOwnerUnknown: (threadId: string) => `Thread ${threadId} has no known owner`,
   ThreadMemberIdsMissing: (action: string) =>

@@ -1,4 +1,5 @@
 import type { Collection } from "@discordjs/collection";
+import { ChannelType } from "discord-api-types/v10";
 import type { GatewayClient } from "../GatewayClient.js";
 import type { Message, PartialMessage } from "../structures/messages/Message.js";
 import type { MessageResolvable } from "../types.js";
@@ -16,15 +17,28 @@ import type {
   MessageEditOptions,
   MessagePayloadResolvable,
 } from "../util/messages.js";
+import { GatewayError } from "../errors/GatewayError.js";
 import { scopeCache, type ScopedCache } from "../util/cache.js";
 import { BaseManager } from "./BaseManager.js";
 
 /**
  * Manages the messages of one channel: `client.messages`, with the channel's ID filled in.
+ *
+ * @remarks
+ * One class serves every channel, where discord.js has a `MessageManager` subclass per kind (`GuildMessageManager`,
+ * `DMMessageManager`, `PartialGroupDMMessageManager`). The methods only a guild has (`crosspost`, `bulkDelete`,
+ * `startThread`) throw `ChannelMessagesGuildOnly` before any request when the manager belongs to a direct message or a
+ * group direct message, which the channel's own `messages` tells. A manager built by hand without the channel's type
+ * sends the request, and Discord refuses it.
  */
 export class ChannelMessageManager extends BaseManager {
   public readonly channelId: string;
 
+  /**
+   * The type of the channel, when known.
+   */
+  public readonly channelType: ChannelType | null;
+
   /**
    * The cached messages of the channel, by message ID.
    *
@@ -35,9 +49,14 @@ export class ChannelMessageManager extends BaseManager {
    */
   public readonly cache: ScopedCache<Message>;
 
-  public constructor(client: GatewayClient, channelId: string) {
+  public constructor(
+    client: GatewayClient,
+    channelId: string,
+    channelType: ChannelType | null = null,
+  ) {
     super(client);
     this.channelId = channelId;
+    this.channelType = channelType;
     this.cache = scopeCache(client.messages.cache, (messageId) =>
       client.messages.resolveKey(channelId, messageId),
     );
@@ -96,14 +115,28 @@ export class ChannelMessageManager extends BaseManager {
     return this.client.messages.unpin(this.channelId, messageId, reason);
   }
 
-  public crosspost(messageId: string): Promise<Message> {
+  /**
+   * Publishes a message of an announcement channel to the channels following it, like discord.js's
+   * `GuildMessageManager#crosspost`.
+   *
+   * @param messageId The ID of the message.
+   * @throws {@link GatewayError} `ChannelMessagesGuildOnly` in a direct message.
+   */
+  public async crosspost(messageId: string): Promise<Message> {
+    this.assertGuild("crosspost");
     return this.client.messages.crosspost(this.channelId, messageId);
   }
 
-  public bulkDelete(
+  /**
+   * Deletes up to 100 messages at once.
+   *
+   * @throws {@link GatewayError} `ChannelMessagesGuildOnly` in a direct message, as the channel has no `bulkDelete`.
+   */
+  public async bulkDelete(
     messages: Collection<string, Message> | readonly MessageResolvable[] | number,
     filterOld = false,
   ): Promise<Collection<string, Message | PartialMessage | undefined>> {
+    this.assertGuild("bulkDelete");
     return this.client.messages.bulkDelete(this.channelId, messages, filterOld);
   }
 
@@ -123,10 +156,16 @@ export class ChannelMessageManager extends BaseManager {
     return this.client.messages.removeAllReactions(this.channelId, messageId);
   }
 
-  public startThread(
+  /**
+   * Starts a thread from a message.
+   *
+   * @throws {@link GatewayError} `ChannelMessagesGuildOnly` in a direct message.
+   */
+  public async startThread(
     messageId: string,
     options: MessageThreadCreateOptions,
   ): Promise<AnyThreadChannel> {
+    this.assertGuild("startThread");
     return this.client.messages.startThread(this.channelId, messageId, options);
   }
 
@@ -141,4 +180,10 @@ export class ChannelMessageManager extends BaseManager {
   ): Promise<User[]> {
     return this.client.messages.fetchPollAnswerVoters(this.channelId, messageId, answerId, options);
   }
+
+  private assertGuild(action: string): void {
+    if (this.channelType === ChannelType.DM || this.channelType === ChannelType.GroupDM) {
+      throw new GatewayError("ChannelMessagesGuildOnly", this.channelId, action);
+    }
+  }
 }
@@ -1,11 +1,12 @@
+import { ChannelType } from "discord-api-types/v10";
 import type { GatewayClient } from "../GatewayClient.js";
 import type {
   AnyThreadChannel,
   FetchArchivedThreadsOptions,
   FetchedThreads,
   ThreadCreateOptions,
 } from "./ThreadManager.js";
-import { GatewayError } from "../errors/GatewayError.js";
+import { GatewayError, GatewayTypeError } from "../errors/GatewayError.js";
 import { BaseManager } from "./BaseManager.js";
 
 /**
@@ -15,18 +16,44 @@ export class ChannelThreadManager extends BaseManager {
   public readonly channelId: string;
   public readonly guildId: string | null;
 
-  public constructor(client: GatewayClient, channelId: string, guildId: string | null) {
+  /**
+   * The type of the channel, when known: it tells a forum or media channel, whose threads are posts created with a
+   * `message`, from a text or announcement channel.
+   */
+  public readonly channelType: ChannelType | null;
+
+  public constructor(
+    client: GatewayClient,
+    channelId: string,
+    guildId: string | null,
+    channelType: ChannelType | null = null,
+  ) {
     super(client);
     this.channelId = channelId;
     this.guildId = guildId;
+    this.channelType = channelType;
   }
 
   /**
-   * Creates a thread in the channel, or a post in a forum or media channel (with `message`).
+   * Creates a thread in the channel, or a post in a forum or media channel (with `message`). discord.js splits this in
+   * `GuildTextThreadManager` and `GuildForumThreadManager`; here the manager is shared and the options are checked
+   * against the type of the channel.
    *
    * @param options The thread's name and settings.
+   * @throws {@link GatewayTypeError} `ThreadPostMessageRequired` in a forum or media channel without `message`,
+   * `ThreadOptionsThreadOnly` there with `type` or `invitable`, and `ThreadOptionsPostOnly` with `message` or
+   * `appliedTags` in any other channel.
    */
-  public create(options: ThreadCreateOptions): Promise<AnyThreadChannel> {
+  public async create(options: ThreadCreateOptions): Promise<AnyThreadChannel> {
+    const { channelType: type } = this;
+    if (type === ChannelType.GuildForum || type === ChannelType.GuildMedia) {
+      if (options.message === undefined) {
+        throw new GatewayTypeError("ThreadPostMessageRequired");
+      }
+    } else if (type !== null && options.message !== undefined) {
+      throw new GatewayTypeError("ThreadOptionsPostOnly", "message");
+    }
+
     return this.client.threads.create(this.channelId, options);
   }
 

@@ -11,6 +11,7 @@ import {
   type ThreadAutoArchiveDuration,
 } from "discord-api-types/v10";
 import type { GatewayClient } from "../GatewayClient.js";
+import { GatewayTypeError } from "../errors/GatewayError.js";
 import type { AnnouncementThreadChannel } from "../structures/channels/AnnouncementThreadChannel.js";
 import type { PrivateThreadChannel } from "../structures/channels/PrivateThreadChannel.js";
 import type { PublicThreadChannel } from "../structures/channels/PublicThreadChannel.js";
@@ -33,32 +34,70 @@ export type AnyThreadChannel =
   | PublicThreadChannel;
 
 /**
- * The options to create a thread with.
+ * The options both kinds of threads are created with.
  */
-export interface ThreadCreateOptions {
+export interface ThreadCreateBaseOptions {
   name: string;
   autoArchiveDuration?: ThreadAutoArchiveDuration;
+  /**
+   * The slowmode of the thread, in seconds. Both threads and forum or media posts take it.
+   */
   rateLimitPerUser?: number;
+  reason?: string;
+}
+
+/**
+ * The options to create a thread of a text or announcement channel with, like discord.js's
+ * `GuildTextThreadCreateOptions`. To start a thread from a message, use `message.startThread()`.
+ */
+export interface TextThreadCreateOptions extends ThreadCreateBaseOptions {
   /**
-   * The type of a thread without a message: public (the default; an announcement thread in announcement channels) or
-   * private.
+   * The type of the thread: public (the default; an announcement thread in announcement channels) or private.
    */
   type?: ChannelType.PublicThread | ChannelType.PrivateThread | ChannelType.AnnouncementThread;
   /**
    * Whether non-moderators can add members to a private thread.
    */
   invitable?: boolean;
   /**
-   * The first message of a forum or media post.
+   * A thread has no first message: use {@link ForumThreadCreateOptions} to create a forum or media post.
    */
-  message?: MessagePayloadResolvable<MessageCreateOptions>;
+  message?: undefined;
   /**
-   * The tags of a forum or media post.
+   * Only forum and media posts have tags.
+   */
+  appliedTags?: undefined;
+}
+
+/**
+ * The options to create a post of a forum or media channel with, like discord.js's `GuildForumThreadCreateOptions`.
+ */
+export interface ForumThreadCreateOptions extends ThreadCreateBaseOptions {
+  /**
+   * The first message of the post.
+   */
+  message: MessagePayloadResolvable<MessageCreateOptions>;
+  /**
+   * The tags of the post.
    */
   appliedTags?: readonly string[];
-  reason?: string;
+  /**
+   * A post is always a public thread.
+   */
+  type?: undefined;
+  /**
+   * A post is always a public thread.
+   */
+  invitable?: undefined;
 }
 
+/**
+ * The options to create a thread with: those of a thread in a text or announcement channel, or with `message`, those
+ * of a post in a forum or media channel. Mixing the two is a compile error, and throws {@link GatewayTypeError}
+ * `ThreadOptionsPostOnly` or `ThreadOptionsThreadOnly` at runtime.
+ */
+export type ThreadCreateOptions = TextThreadCreateOptions | ForumThreadCreateOptions;
+
 /**
  * The options to fetch archived threads with.
  */
@@ -122,8 +161,24 @@ export class ThreadManager extends CachedManager<"threads", AnyThreadChannel, [t
    *
    * @param channelId The ID of the parent channel.
    * @param options The thread's name and settings, and the first message of a post.
+   * @throws {@link GatewayTypeError} `ThreadOptionsPostOnly` when `appliedTags` is set without `message`, and
+   * `ThreadOptionsThreadOnly` when `type` or `invitable` is set with it.
    */
   public async create(channelId: string, options: ThreadCreateOptions): Promise<AnyThreadChannel> {
+    // The types forbid these mixes, but a cast or untyped code still reaches Discord, which ignores the options.
+    if (options.message === undefined) {
+      if (options.appliedTags !== undefined) {
+        throw new GatewayTypeError("ThreadOptionsPostOnly", "appliedTags");
+      }
+    } else {
+      const inapplicable = (["type", "invitable"] as const).filter(
+        (option) => options[option] !== undefined,
+      );
+      if (inapplicable.length > 0) {
+        throw new GatewayTypeError("ThreadOptionsThreadOnly", inapplicable.join(", "));
+      }
+    }
+
     const common = {
       name: options.name,
       auto_archive_duration: options.autoArchiveDuration,

@@ -17,6 +17,11 @@ export class ChannelThreadsMixin<Type extends ChannelType = ChannelType> {
    * The threads of the channel.
    */
   public get threads(): ChannelThreadManager {
-    return new ChannelThreadManager(this.client, this.id, (this[kData] as Data).guild_id ?? null);
+    return new ChannelThreadManager(
+      this.client,
+      this.id,
+      (this[kData] as Data).guild_id ?? null,
+      this.type,
+    );
   }
 }
@@ -58,7 +58,7 @@ export class TextChannelMixin<Type extends ChannelType = ChannelType> {
    * The messages of the channel.
    */
   public get messages(): ChannelMessageManager {
-    return new ChannelMessageManager(this.client, this.id);
+    return new ChannelMessageManager(this.client, this.id, this.type);
   }
 
   /**