@copilotkit/channels-discord 0.0.2

package/dist/commands.test.js

@@ -0,0 +1,281 @@
+import { describe, it, expect, vi } from "vitest";
+import { jsonSchemaToDiscordOptions, buildCommandBody, registerCommands, } from "./commands.js";
+describe("jsonSchemaToDiscordOptions", () => {
+    it("maps primitive properties to typed options with required flags", () => {
+        const opts = jsonSchemaToDiscordOptions({
+            type: "object",
+            properties: {
+                priority: {
+                    type: "string",
+                    enum: ["low", "high"],
+                    description: "How urgent",
+                },
+                count: { type: "integer" },
+                notify: { type: "boolean" },
+            },
+            required: ["priority"],
+        });
+        // String option type = 3, Integer = 4, Boolean = 5 (Discord ApplicationCommandOptionType).
+        const priority = opts.find((o) => o.name === "priority");
+        expect(priority.type).toBe(3);
+        expect(priority.required).toBe(true);
+        expect(priority.choices).toEqual([
+            { name: "low", value: "low" },
+            { name: "high", value: "high" },
+        ]);
+        expect(opts.find((o) => o.name === "count").type).toBe(4);
+        expect(opts.find((o) => o.name === "notify").type).toBe(5);
+        expect(opts.find((o) => o.name === "count").required).toBe(false);
+    });
+    it("degrades an unsupported (nested object) property to a free-text string option", () => {
+        const warn = vi.spyOn(console, "warn").mockImplementation(() => { });
+        const opts = jsonSchemaToDiscordOptions({
+            type: "object",
+            properties: { meta: { type: "object" } },
+        });
+        expect(opts[0]).toMatchObject({ name: "meta", type: 3 });
+        expect(warn).toHaveBeenCalled();
+        warn.mockRestore();
+    });
+    it("returns [] for a free-text command (no options schema)", () => {
+        expect(jsonSchemaToDiscordOptions(undefined)).toEqual([]);
+    });
+    it("orders required options before optional ones (Discord requirement)", () => {
+        const opts = jsonSchemaToDiscordOptions({
+            type: "object",
+            properties: {
+                note: { type: "string" },
+                priority: { type: "string" },
+            },
+            required: ["priority"],
+        });
+        // `note` is declared first but is optional; `priority` must come first.
+        expect(opts.map((o) => o.name)).toEqual(["priority", "note"]);
+        expect(opts[0].required).toBe(true);
+        expect(opts[1].required).toBe(false);
+    });
+    it("builds numeric choices for an integer enum", () => {
+        const opts = jsonSchemaToDiscordOptions({
+            type: "object",
+            properties: { level: { type: "integer", enum: [1, 2, 3] } },
+        });
+        const level = opts.find((o) => o.name === "level");
+        expect(level.type).toBe(4);
+        expect(level.choices).toEqual([
+            { name: "1", value: 1 },
+            { name: "2", value: 2 },
+            { name: "3", value: 3 },
+        ]);
+    });
+    it("skips non-numeric enum entries for an integer option (NaN would reject the batch)", () => {
+        const warn = vi.spyOn(console, "warn").mockImplementation(() => { });
+        const opts = jsonSchemaToDiscordOptions({
+            type: "object",
+            properties: { level: { type: "integer", enum: [1, "x", 3] } },
+        });
+        const level = opts.find((o) => o.name === "level");
+        expect(level.type).toBe(4);
+        // "x" → NaN → dropped; only finite values survive.
+        expect(level.choices).toEqual([
+            { name: "1", value: 1 },
+            { name: "3", value: 3 },
+        ]);
+        expect(warn).toHaveBeenCalled();
+        warn.mockRestore();
+    });
+    it("normalizes a nullable array type (['string','null']) to a String option, not the warn path", () => {
+        const warn = vi.spyOn(console, "warn").mockImplementation(() => { });
+        const opts = jsonSchemaToDiscordOptions({
+            type: "object",
+            properties: { note: { type: ["string", "null"] } },
+        });
+        const note = opts.find((o) => o.name === "note");
+        expect(note.type).toBe(3); // String, not the default-warn fallthrough
+        expect(warn).not.toHaveBeenCalled();
+        warn.mockRestore();
+    });
+    it("omits the choices key (not []) when an integer enum has no numeric entries", () => {
+        const warn = vi.spyOn(console, "warn").mockImplementation(() => { });
+        const opts = jsonSchemaToDiscordOptions({
+            type: "object",
+            properties: { level: { type: "integer", enum: ["a", "b", "c"] } },
+        });
+        const level = opts.find((o) => o.name === "level");
+        expect(level.type).toBe(4);
+        // No choices key at all — an empty `choices: []` would make Discord reject the batch.
+        expect("choices" in level).toBe(false);
+        expect(level.choices).toBeUndefined();
+        warn.mockRestore();
+    });
+    it("drops non-integer values from an integer enum (1.5 is not an integer)", () => {
+        const opts = jsonSchemaToDiscordOptions({
+            type: "object",
+            properties: { level: { type: "integer", enum: [1, 1.5, 2] } },
+        });
+        const level = opts.find((o) => o.name === "level");
+        expect(level.choices).toEqual([
+            { name: "1", value: 1 },
+            { name: "2", value: 2 },
+        ]);
+    });
+    it("keeps non-integer finite values for a number (float) enum", () => {
+        const opts = jsonSchemaToDiscordOptions({
+            type: "object",
+            properties: { ratio: { type: "number", enum: [1, 1.5, 2] } },
+        });
+        const ratio = opts.find((o) => o.name === "ratio");
+        expect(ratio.type).toBe(10);
+        expect(ratio.choices).toEqual([
+            { name: "1", value: 1 },
+            { name: "1.5", value: 1.5 },
+            { name: "2", value: 2 },
+        ]);
+    });
+    it("skips an empty-name choice (String('') is whitespace, Number('') is a finite 0)", () => {
+        const warn = vi.spyOn(console, "warn").mockImplementation(() => { });
+        const intOpts = jsonSchemaToDiscordOptions({
+            type: "object",
+            properties: { level: { type: "integer", enum: ["", 1] } },
+        });
+        expect(intOpts.find((o) => o.name === "level").choices).toEqual([
+            { name: "1", value: 1 },
+        ]);
+        const strOpts = jsonSchemaToDiscordOptions({
+            type: "object",
+            properties: { tag: { type: "string", enum: ["", " ", "ok"] } },
+        });
+        expect(strOpts.find((o) => o.name === "tag").choices).toEqual([
+            { name: "ok", value: "ok" },
+        ]);
+        warn.mockRestore();
+    });
+    it("clamps an enum with more than 25 values to exactly 25 choices", () => {
+        const warn = vi.spyOn(console, "warn").mockImplementation(() => { });
+        const thirty = Array.from({ length: 30 }, (_, i) => i + 1);
+        const intOpts = jsonSchemaToDiscordOptions({
+            type: "object",
+            properties: { level: { type: "integer", enum: thirty } },
+        });
+        expect(intOpts.find((o) => o.name === "level").choices.length).toBe(25);
+        const strOpts = jsonSchemaToDiscordOptions({
+            type: "object",
+            properties: { tag: { type: "string", enum: thirty.map((n) => `v${n}`) } },
+        });
+        expect(strOpts.find((o) => o.name === "tag").choices.length).toBe(25);
+        warn.mockRestore();
+    });
+    it("clamps a command to at most 25 options", () => {
+        const warn = vi.spyOn(console, "warn").mockImplementation(() => { });
+        const properties = {};
+        for (let i = 0; i < 30; i++)
+            properties[`opt${i}`] = { type: "string" };
+        const opts = jsonSchemaToDiscordOptions({ type: "object", properties });
+        expect(opts.length).toBe(25);
+        warn.mockRestore();
+    });
+    it("normalizes an option name to a lowercase valid slug (<=32, matches ^[-_a-z0-9]+$)", () => {
+        const opts = jsonSchemaToDiscordOptions({
+            type: "object",
+            properties: { "My Opt Name!": { type: "string" } },
+        });
+        const name = opts[0].name;
+        expect(name).toMatch(/^[-_a-z0-9]+$/);
+        expect(name.length).toBeGreaterThanOrEqual(1);
+        expect(name.length).toBeLessThanOrEqual(32);
+    });
+    it("skips a string choice whose value exceeds 100 chars (a truncated value would fail enum validation), but keeps a <=100-char member with its exact value", () => {
+        const warn = vi.spyOn(console, "warn").mockImplementation(() => { });
+        const long = "z".repeat(120);
+        const short = "z".repeat(100);
+        const strOpts = jsonSchemaToDiscordOptions({
+            type: "object",
+            properties: { tag: { type: "string", enum: [long, short, "ok"] } },
+        });
+        const choices = strOpts.find((o) => o.name === "tag").choices;
+        // The >100-char member is dropped entirely — NOT emitted with a truncated value.
+        expect(choices.some((c) => String(c.value).endsWith("…") || String(c.value).length > 100)).toBe(false);
+        expect(choices.some((c) => c.value === long)).toBe(false);
+        // The <=100-char members survive with their exact (round-trippable) value.
+        expect(choices).toContainEqual({ name: short, value: short });
+        expect(choices).toContainEqual({ name: "ok", value: "ok" });
+        expect(warn).toHaveBeenCalled();
+        warn.mockRestore();
+    });
+    it("truncates a long choice name (display-only) while keeping the value exact when <=100 chars", () => {
+        // A value of exactly 100 chars is kept verbatim; the name is display-only and may be truncated,
+        // but at 100 chars it is already within the name cap so it too stays intact.
+        const value = "v".repeat(100);
+        const strOpts = jsonSchemaToDiscordOptions({
+            type: "object",
+            properties: { tag: { type: "string", enum: [value] } },
+        });
+        const choice = strOpts.find((o) => o.name === "tag").choices[0];
+        expect(choice.value).toBe(value);
+        expect(String(choice.value).length).toBe(100);
+        expect(choice.name.length).toBeLessThanOrEqual(100);
+        const intOpts = jsonSchemaToDiscordOptions({
+            type: "object",
+            properties: {
+                level: { type: "integer", enum: [Number("1".repeat(120))] },
+            },
+        });
+        // A 120-digit number → Infinity (not finite/integer) → dropped, so just assert no crash.
+        expect(intOpts.find((o) => o.name === "level")).toBeTruthy();
+    });
+    it("truncates an option description longer than 100 chars", () => {
+        const long = "x".repeat(250);
+        const opts = jsonSchemaToDiscordOptions({
+            type: "object",
+            properties: { note: { type: "string", description: long } },
+        });
+        const note = opts.find((o) => o.name === "note");
+        expect(note.description.length).toBeLessThanOrEqual(100);
+    });
+});
+describe("buildCommandBody", () => {
+    it("truncates a command description longer than 100 chars", () => {
+        const long = "y".repeat(250);
+        const body = buildCommandBody({
+            name: "triage",
+            description: long,
+            options: undefined,
+        });
+        expect(body.description.length).toBeLessThanOrEqual(100);
+    });
+    it("normalizes a command name to a lowercase valid slug (<=32, matches ^[-_a-z0-9]+$)", () => {
+        const body = buildCommandBody({
+            name: "MyCmd Name!",
+            description: "x",
+            options: undefined,
+        });
+        expect(body.name).toMatch(/^[-_a-z0-9]+$/);
+        expect(body.name).toBe(body.name.toLowerCase());
+        expect(body.name.length).toBeGreaterThanOrEqual(1);
+        expect(body.name.length).toBeLessThanOrEqual(32);
+    });
+});
+describe("registerCommands", () => {
+    const spec = {
+        name: "triage",
+        description: "Triage the thread",
+        options: undefined,
+    };
+    it("registers to a guild when guildId is set", async () => {
+        const put = vi.fn(async (_route, _opts) => { });
+        await registerCommands({ put }, "app-1", "guild-9", [spec]);
+        expect(put).toHaveBeenCalledTimes(1);
+        const [route, body] = put.mock.calls[0];
+        expect(String(route)).toContain("guild-9");
+        expect(body.body[0]).toMatchObject({
+            name: "triage",
+            description: "Triage the thread",
+        });
+    });
+    it("registers globally when guildId is absent", async () => {
+        const put = vi.fn(async (_route, _opts) => { });
+        await registerCommands({ put }, "app-1", undefined, [spec]);
+        const [route] = put.mock.calls[0];
+        expect(String(route)).not.toContain("guild");
+        expect(String(route)).toContain("app-1");
+    });
+});

package/dist/conversation-store.d.ts

@@ -0,0 +1,45 @@
+import type { AbstractAgent } from "@ag-ui/client";
+import type { ConversationStore, AgentSession, ReplyTarget as BotReplyTarget } from "@copilotkit/channels";
+import type { DiscordAttachmentRef, FileDeliveryConfig } from "./download-files.js";
+/** A single Discord message, normalized for history reconstruction. */
+export interface DiscordHistoryMessage {
+    id: string;
+    content: string;
+    authorId?: string;
+    authorIsBot?: boolean;
+    attachments: DiscordAttachmentRef[];
+}
+/**
+ * Backed entirely by the Discord channel: every turn pulls the current
+ * channel/thread history, translates it into the AG-UI message shape, and hands
+ * a fresh agent to the turn-runner with its `messages` set to that history.
+ * Mirrors bot-slack's store — the platform is the durable storage, so the
+ * bridge keeps no separate per-conversation state. The inbound (triggering)
+ * message is part of the reconstructed history, so the app passes NO prompt.
+ */
+export declare class DiscordConversationStore implements ConversationStore {
+    private deps;
+    constructor(deps: {
+        /** Channel history, OLDEST→NEWEST. */
+        fetchHistory: (channelId: string) => Promise<DiscordHistoryMessage[]>;
+        /** The bot's own user id (lazily resolved after `ready`). */
+        botUserId: () => string;
+        /** Inbound-file handling tunables (size caps, fetch impl, …). */
+        filesConfig?: FileDeliveryConfig;
+    });
+    /**
+     * Build a fresh AgentSession for this conversation by fetching its Discord
+     * history and translating it into the AG-UI message shape. Rebuilt every
+     * turn (no in-memory cache) — the Discord channel is the source of truth.
+     */
+    getOrCreate(conversationKey: string, _replyTarget: BotReplyTarget, makeAgent: (threadId: string) => AbstractAgent): Promise<AgentSession>;
+    /**
+     * Fetch the channel history (oldest→newest) and translate it into AG-UI
+     * messages, folding the bot's chunked replies into a single assistant turn,
+     * skipping the bot's own stream placeholders, stripping mention tokens from
+     * user text, and turning a user message's uploaded files into multimodal
+     * content (bot-slack parity).
+     */
+    private reconstruct;
+}
+//# sourceMappingURL=conversation-store.d.ts.map

package/dist/conversation-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-store.d.ts","sourceRoot":"","sources":["../src/conversation-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EACV,iBAAiB,EACjB,YAAY,EACZ,WAAW,IAAI,cAAc,EAC9B,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAEV,oBAAoB,EACpB,kBAAkB,EACnB,MAAM,qBAAqB,CAAC;AAG7B,uEAAuE;AACvE,MAAM,WAAW,qBAAqB;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,EAAE,oBAAoB,EAAE,CAAC;CACrC;AAED;;;;;;;GAOG;AACH,qBAAa,wBAAyB,YAAW,iBAAiB;IAE9D,OAAO,CAAC,IAAI;gBAAJ,IAAI,EAAE;QACZ,sCAAsC;QACtC,YAAY,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAAC;QACtE,6DAA6D;QAC7D,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,iEAAiE;QACjE,WAAW,CAAC,EAAE,kBAAkB,CAAC;KAClC;IAGH;;;;OAIG;IACG,WAAW,CACf,eAAe,EAAE,MAAM,EACvB,YAAY,EAAE,cAAc,EAC5B,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,aAAa,GAC7C,OAAO,CAAC,YAAY,CAAC;IAOxB;;;;;;OAMG;YACW,WAAW;CA+C1B"}

package/dist/conversation-store.js

@@ -0,0 +1,78 @@
+import { buildFileContentParts } from "./download-files.js";
+import { STREAM_PLACEHOLDERS } from "./chunked-message-stream.js";
+/**
+ * Backed entirely by the Discord channel: every turn pulls the current
+ * channel/thread history, translates it into the AG-UI message shape, and hands
+ * a fresh agent to the turn-runner with its `messages` set to that history.
+ * Mirrors bot-slack's store — the platform is the durable storage, so the
+ * bridge keeps no separate per-conversation state. The inbound (triggering)
+ * message is part of the reconstructed history, so the app passes NO prompt.
+ */
+export class DiscordConversationStore {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /**
+     * Build a fresh AgentSession for this conversation by fetching its Discord
+     * history and translating it into the AG-UI message shape. Rebuilt every
+     * turn (no in-memory cache) — the Discord channel is the source of truth.
+     */
+    async getOrCreate(conversationKey, _replyTarget, makeAgent) {
+        const agent = makeAgent(conversationKey);
+        const history = await this.reconstruct(conversationKey);
+        agent.messages = history;
+        return { agent };
+    }
+    /**
+     * Fetch the channel history (oldest→newest) and translate it into AG-UI
+     * messages, folding the bot's chunked replies into a single assistant turn,
+     * skipping the bot's own stream placeholders, stripping mention tokens from
+     * user text, and turning a user message's uploaded files into multimodal
+     * content (bot-slack parity).
+     */
+    async reconstruct(channelId) {
+        const botId = this.deps.botUserId();
+        const messages = await this.deps.fetchHistory(channelId);
+        const out = [];
+        for (const m of messages) {
+            const isBot = m.authorIsBot || m.authorId === botId;
+            // Skip the bot's own streaming placeholders ("_thinking…_" / "…(continued)").
+            if (isBot && STREAM_PLACEHOLDERS.includes(m.content))
+                continue;
+            const text = isBot
+                ? m.content
+                : m.content
+                    .replace(/<@!?\d+>/g, "")
+                    .replace(/\s+/g, " ")
+                    .trim();
+            const hasFiles = !isBot && m.attachments.length > 0;
+            if (!text && !hasFiles)
+                continue;
+            const role = isBot ? "assistant" : "user";
+            // User message with uploaded files → multimodal content (the agent's
+            // model reads the images / decoded text).
+            if (hasFiles) {
+                const parts = await buildFileContentParts(m.attachments, this.deps.filesConfig);
+                const content = [];
+                if (text)
+                    content.push({ type: "text", text });
+                content.push(...parts);
+                if (content.length === 0)
+                    continue; // nothing usable
+                out.push({ id: m.id, role, content });
+                continue;
+            }
+            // Fold consecutive same-role *string* messages — the bot's chunked
+            // replies are one assistant turn rendered as N Discord messages.
+            const tail = out[out.length - 1];
+            if (tail && tail.role === role && typeof tail.content === "string") {
+                tail.content = `${tail.content}\n${text}`;
+            }
+            else {
+                out.push({ id: m.id, role, content: text });
+            }
+        }
+        return out;
+    }
+}

package/dist/conversation-store.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=conversation-store.test.d.ts.map

package/dist/conversation-store.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-store.test.d.ts","sourceRoot":"","sources":["../src/conversation-store.test.ts"],"names":[],"mappings":""}

package/dist/conversation-store.test.js

@@ -0,0 +1,106 @@
+import { describe, it, expect, vi } from "vitest";
+import { DiscordConversationStore } from "./conversation-store.js";
+/** Captures the `messages` assigned onto the fake agent by the store. */
+function fakeAgent() {
+    return { threadId: "", messages: undefined };
+}
+describe("DiscordConversationStore", () => {
+    it("reconstructs channel history into AG-UI messages each turn", async () => {
+        const pngBytes = new Uint8Array([0x89, 0x50, 0x4e, 0x47]);
+        // A stubbed fetch for buildFileContentParts so no real network happens.
+        const fetchImpl = vi.fn(async () => ({
+            ok: true,
+            arrayBuffer: async () => pngBytes.buffer,
+        }));
+        const history = [
+            {
+                id: "m1",
+                content: "<@123> hey bot",
+                authorId: "u1",
+                authorIsBot: false,
+                attachments: [],
+            },
+            {
+                id: "m2",
+                content: "_thinking…_", // bot placeholder — must be skipped
+                authorId: "bot-1",
+                authorIsBot: true,
+                attachments: [],
+            },
+            {
+                id: "m3",
+                content: "here is the",
+                authorId: "bot-1",
+                authorIsBot: true,
+                attachments: [],
+            },
+            {
+                id: "m4",
+                content: "real answer", // consecutive bot string → folded into m3
+                authorId: "bot-1",
+                authorIsBot: true,
+                attachments: [],
+            },
+            {
+                id: "m5",
+                content: "<@123> look at this",
+                authorId: "u1",
+                authorIsBot: false,
+                attachments: [
+                    {
+                        url: "https://cdn.discord/a.png",
+                        name: "a.png",
+                        contentType: "image/png",
+                        size: pngBytes.length,
+                    },
+                ],
+            },
+        ];
+        const fetchHistory = vi.fn(async () => history);
+        const store = new DiscordConversationStore({
+            fetchHistory,
+            botUserId: () => "bot-1",
+            filesConfig: { fetchImpl },
+        });
+        const agent = fakeAgent();
+        const session = await store.getOrCreate("c1", { channelId: "c1" }, () => agent);
+        expect(fetchHistory).toHaveBeenCalledWith("c1");
+        expect(session.agent).toBe(agent);
+        expect(agent.messages).toEqual([
+            // user text, mention token stripped
+            { id: "m1", role: "user", content: "hey bot" },
+            // placeholder skipped; two consecutive bot strings folded into one turn
+            { id: "m3", role: "assistant", content: "here is the\nreal answer" },
+            // user message with an image → multimodal content (text part + image part)
+            {
+                id: "m5",
+                role: "user",
+                content: [
+                    { type: "text", text: "look at this" },
+                    {
+                        type: "image",
+                        source: {
+                            type: "data",
+                            value: Buffer.from(pngBytes).toString("base64"),
+                            mimeType: "image/png",
+                        },
+                    },
+                ],
+            },
+        ]);
+    });
+    it("rebuilds from the channel every turn (no in-memory caching)", async () => {
+        const fetchHistory = vi.fn(async () => []);
+        const store = new DiscordConversationStore({
+            fetchHistory,
+            botUserId: () => "bot-1",
+        });
+        const makeAgent = vi.fn(() => fakeAgent());
+        await store.getOrCreate("c1", { channelId: "c1" }, makeAgent);
+        await store.getOrCreate("c1", { channelId: "c1" }, makeAgent);
+        // A fresh agent + a fresh history fetch per turn — the channel is the
+        // source of truth, so nothing is cached.
+        expect(makeAgent).toHaveBeenCalledTimes(2);
+        expect(fetchHistory).toHaveBeenCalledTimes(2);
+    });
+});

package/dist/discord-listener.d.ts

@@ -0,0 +1,88 @@
+import type { IncomingReaction } from "@copilotkit/channels";
+import type { IncomingTurn, ReplyTarget } from "./types.js";
+import type { PendingInteractions } from "./pending-interactions.js";
+interface MessageLike {
+    author: {
+        id: string;
+        bot?: boolean;
+        username?: string;
+        globalName?: string | null;
+    };
+    content: string;
+    channelId: string;
+    guildId?: string | null;
+    mentions: {
+        has(id: string): boolean;
+        users?: {
+            has(id: string): boolean;
+        };
+    };
+    channel: {
+        isDMBased(): boolean;
+    };
+}
+interface ChatInputLike {
+    isChatInputCommand(): boolean;
+    /** Discord interaction id — used as the pending-interaction triggerId. */
+    id: string;
+    commandName: string;
+    channelId: string;
+    guildId?: string | null;
+    user: {
+        id: string;
+        username?: string;
+        globalName?: string | null;
+    };
+    options: {
+        data: ReadonlyArray<{
+            name: string;
+            value: unknown;
+        }>;
+    };
+    /** discord.js interaction state — set once the interaction has been deferred. */
+    deferred?: boolean;
+    /** discord.js interaction state — set once a reply has been sent. */
+    replied?: boolean;
+    /** Remove the (deferred) reply. Used to clear a dangling ephemeral ack. */
+    deleteReply?: () => Promise<unknown>;
+}
+export interface ClientLike {
+    on(event: "messageCreate", cb: (msg: MessageLike) => void): void;
+    on(event: "interactionCreate", cb: (i: ChatInputLike) => void): void;
+    on(event: "messageReactionAdd" | "messageReactionRemove", cb: (reaction: unknown, user: unknown) => void): void;
+    on(event: string, cb: (arg: unknown) => void): void;
+}
+export interface IncomingCommandRaw {
+    command: string;
+    text: string;
+    rawOptions: Record<string, unknown>;
+    conversationKey: string;
+    replyTarget: ReplyTarget;
+    senderUserId: string;
+    /** Pending-interaction triggerId (the live interaction id) — backs `openModal`. */
+    triggerId?: string;
+}
+export interface ListenerConfig {
+    client: ClientLike;
+    /**
+     * The bot's own user id. May be a getter so the adapter can attach the
+     * listener once at startup and supply the id lazily after the `ready`
+     * event (when it first becomes known).
+     */
+    botUserId: string | (() => string);
+    onTurn(turn: IncomingTurn): void | Promise<void>;
+    onCommand(cmd: IncomingCommandRaw): void | Promise<void>;
+    /** Optional: called when a user adds or removes a reaction. */
+    onReaction?: (evt: IncomingReaction) => void | Promise<void>;
+    /**
+     * Pending-interaction registry for slash commands. The live command
+     * interaction is registered (arming an auto-`deferReply`), dispatched with a
+     * `triggerId` so a handler may `openModal` first, then settled. When absent,
+     * the command path skips registration (no modal support / no ack).
+     */
+    commandPending?: PendingInteractions;
+}
+/** Wire Gateway events to normalized turns/commands. Mirrors attachSlackListener. */
+export declare function attachDiscordListener(cfg: ListenerConfig): void;
+export {};
+//# sourceMappingURL=discord-listener.d.ts.map

package/dist/discord-listener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discord-listener.d.ts","sourceRoot":"","sources":["../src/discord-listener.ts"],"names":[],"mappings":"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"}